//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS QBusiness service.
///
/// This is the Amazon Q Business API Reference. Amazon Q Business is a fully managed, generative-AI powered enterprise chat assistant that you can deploy within your organization. Amazon Q Business enhances employee productivity by supporting key tasks such as question-answering, knowledge discovery, writing email messages, summarizing text, drafting document outlines, and brainstorming ideas. Users ask questions of Amazon Q Business and get answers that are presented in a conversational manner. For an introduction to the service, see the  Amazon Q Business User Guide . For an overview of the Amazon Q Business APIs, see Overview of Amazon Q Business API operations. For information about the IAM access control permissions you need to use this API, see IAM roles for Amazon Q Business in the Amazon Q Business User Guide. The following resources provide additional information about using the Amazon Q Business API:     Setting up for Amazon Q Business       Amazon Q Business CLI Reference       Amazon Web Services General Reference
public struct QBusiness: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the QBusiness client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "QBusiness",
            serviceIdentifier: "qbusiness",
            serviceProtocol: .restjson,
            apiVersion: "2023-11-27",
            endpoint: endpoint,
            serviceEndpoints: Self.serviceEndpoints,
            variantEndpoints: Self.variantEndpoints,
            errorType: QBusinessErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }


    /// custom endpoints for regions
    static var serviceEndpoints: [String: String] {[
        "af-south-1": "qbusiness.af-south-1.api.aws",
        "ap-east-1": "qbusiness.ap-east-1.api.aws",
        "ap-northeast-1": "qbusiness.ap-northeast-1.api.aws",
        "ap-northeast-2": "qbusiness.ap-northeast-2.api.aws",
        "ap-northeast-3": "qbusiness.ap-northeast-3.api.aws",
        "ap-south-1": "qbusiness.ap-south-1.api.aws",
        "ap-south-2": "qbusiness.ap-south-2.api.aws",
        "ap-southeast-1": "qbusiness.ap-southeast-1.api.aws",
        "ap-southeast-2": "qbusiness.ap-southeast-2.api.aws",
        "ap-southeast-3": "qbusiness.ap-southeast-3.api.aws",
        "ap-southeast-4": "qbusiness.ap-southeast-4.api.aws",
        "ap-southeast-5": "qbusiness.ap-southeast-5.api.aws",
        "ap-southeast-7": "qbusiness.ap-southeast-7.api.aws",
        "ca-central-1": "qbusiness.ca-central-1.api.aws",
        "ca-west-1": "qbusiness.ca-west-1.api.aws",
        "cn-north-1": "qbusiness.cn-north-1.api.amazonwebservices.com.cn",
        "cn-northwest-1": "qbusiness.cn-northwest-1.api.amazonwebservices.com.cn",
        "eu-central-1": "qbusiness.eu-central-1.api.aws",
        "eu-central-2": "qbusiness.eu-central-2.api.aws",
        "eu-north-1": "qbusiness.eu-north-1.api.aws",
        "eu-south-1": "qbusiness.eu-south-1.api.aws",
        "eu-south-2": "qbusiness.eu-south-2.api.aws",
        "eu-west-1": "qbusiness.eu-west-1.api.aws",
        "eu-west-2": "qbusiness.eu-west-2.api.aws",
        "eu-west-3": "qbusiness.eu-west-3.api.aws",
        "il-central-1": "qbusiness.il-central-1.api.aws",
        "me-central-1": "qbusiness.me-central-1.api.aws",
        "me-south-1": "qbusiness.me-south-1.api.aws",
        "mx-central-1": "qbusiness.mx-central-1.api.aws",
        "sa-east-1": "qbusiness.sa-east-1.api.aws",
        "us-east-1": "qbusiness.us-east-1.api.aws",
        "us-east-2": "qbusiness.us-east-2.api.aws",
        "us-gov-east-1": "qbusiness.us-gov-east-1.api.aws",
        "us-gov-west-1": "qbusiness.us-gov-west-1.api.aws",
        "us-west-1": "qbusiness.us-west-1.api.aws",
        "us-west-2": "qbusiness.us-west-2.api.aws"
    ]}


    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "af-south-1": "qbusiness-fips.af-south-1.api.aws",
            "ap-east-1": "qbusiness-fips.ap-east-1.api.aws",
            "ap-east-2": "qbusiness-fips.ap-east-2.api.aws",
            "ap-northeast-1": "qbusiness-fips.ap-northeast-1.api.aws",
            "ap-northeast-2": "qbusiness-fips.ap-northeast-2.api.aws",
            "ap-northeast-3": "qbusiness-fips.ap-northeast-3.api.aws",
            "ap-south-1": "qbusiness-fips.ap-south-1.api.aws",
            "ap-south-2": "qbusiness-fips.ap-south-2.api.aws",
            "ap-southeast-1": "qbusiness-fips.ap-southeast-1.api.aws",
            "ap-southeast-2": "qbusiness-fips.ap-southeast-2.api.aws",
            "ap-southeast-3": "qbusiness-fips.ap-southeast-3.api.aws",
            "ap-southeast-4": "qbusiness-fips.ap-southeast-4.api.aws",
            "ap-southeast-5": "qbusiness-fips.ap-southeast-5.api.aws",
            "ap-southeast-7": "qbusiness-fips.ap-southeast-7.api.aws",
            "ca-central-1": "qbusiness-fips.ca-central-1.api.aws",
            "ca-west-1": "qbusiness-fips.ca-west-1.api.aws",
            "cn-north-1": "qbusiness-fips.cn-north-1.api.amazonwebservices.com.cn",
            "cn-northwest-1": "qbusiness-fips.cn-northwest-1.api.amazonwebservices.com.cn",
            "eu-central-1": "qbusiness-fips.eu-central-1.api.aws",
            "eu-central-2": "qbusiness-fips.eu-central-2.api.aws",
            "eu-north-1": "qbusiness-fips.eu-north-1.api.aws",
            "eu-south-1": "qbusiness-fips.eu-south-1.api.aws",
            "eu-south-2": "qbusiness-fips.eu-south-2.api.aws",
            "eu-west-1": "qbusiness-fips.eu-west-1.api.aws",
            "eu-west-2": "qbusiness-fips.eu-west-2.api.aws",
            "eu-west-3": "qbusiness-fips.eu-west-3.api.aws",
            "il-central-1": "qbusiness-fips.il-central-1.api.aws",
            "me-central-1": "qbusiness-fips.me-central-1.api.aws",
            "me-south-1": "qbusiness-fips.me-south-1.api.aws",
            "mx-central-1": "qbusiness-fips.mx-central-1.api.aws",
            "sa-east-1": "qbusiness-fips.sa-east-1.api.aws",
            "us-east-1": "qbusiness-fips.us-east-1.api.aws",
            "us-east-2": "qbusiness-fips.us-east-2.api.aws",
            "us-gov-east-1": "qbusiness-fips.us-gov-east-1.api.aws",
            "us-gov-west-1": "qbusiness-fips.us-gov-west-1.api.aws",
            "us-west-1": "qbusiness-fips.us-west-1.api.aws",
            "us-west-2": "qbusiness-fips.us-west-2.api.aws"
        ])
    ]}

    // MARK: API Calls

    /// Adds or updates a permission policy for a Amazon Q Business application, allowing cross-account access for an ISV. This operation creates a new policy statement for the specified Amazon Q Business application. The policy statement defines the IAM actions that the ISV is allowed to perform on the Amazon Q Business application's resources.
    @Sendable
    @inlinable
    public func associatePermission(_ input: AssociatePermissionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociatePermissionResponse {
        try await self.client.execute(
            operation: "AssociatePermission", 
            path: "/applications/{applicationId}/policy", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds or updates a permission policy for a Amazon Q Business application, allowing cross-account access for an ISV. This operation creates a new policy statement for the specified Amazon Q Business application. The policy statement defines the IAM actions that the ISV is allowed to perform on the Amazon Q Business application's resources.
    ///
    /// Parameters:
    ///   - actions: The list of Amazon Q Business actions that the ISV is allowed to perform.
    ///   - applicationId: The unique identifier of the Amazon Q Business application.
    ///   - conditions: The conditions that restrict when the permission is effective. These conditions can be used to limit the permission based on specific attributes of the request.
    ///   - principal: The Amazon Resource Name of the IAM role for the ISV that is being granted permission.
    ///   - statementId: A unique identifier for the policy statement.
    ///   - logger: Logger use during operation
    @inlinable
    public func associatePermission(
        actions: [String],
        applicationId: String,
        conditions: [PermissionCondition]? = nil,
        principal: String,
        statementId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociatePermissionResponse {
        let input = AssociatePermissionRequest(
            actions: actions, 
            applicationId: applicationId, 
            conditions: conditions, 
            principal: principal, 
            statementId: statementId
        )
        return try await self.associatePermission(input, logger: logger)
    }

    /// Asynchronously deletes one or more documents added using the BatchPutDocument API from an Amazon Q Business index. You can see the progress of the deletion, and any error messages related to the process, by using CloudWatch.
    @Sendable
    @inlinable
    public func batchDeleteDocument(_ input: BatchDeleteDocumentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchDeleteDocumentResponse {
        try await self.client.execute(
            operation: "BatchDeleteDocument", 
            path: "/applications/{applicationId}/indices/{indexId}/documents/delete", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Asynchronously deletes one or more documents added using the BatchPutDocument API from an Amazon Q Business index. You can see the progress of the deletion, and any error messages related to the process, by using CloudWatch.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application.
    ///   - dataSourceSyncId: The identifier of the data source sync during which the documents were deleted.
    ///   - documents: Documents deleted from the Amazon Q Business index.
    ///   - indexId: The identifier of the Amazon Q Business index that contains the documents to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchDeleteDocument(
        applicationId: String,
        dataSourceSyncId: String? = nil,
        documents: [DeleteDocument],
        indexId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchDeleteDocumentResponse {
        let input = BatchDeleteDocumentRequest(
            applicationId: applicationId, 
            dataSourceSyncId: dataSourceSyncId, 
            documents: documents, 
            indexId: indexId
        )
        return try await self.batchDeleteDocument(input, logger: logger)
    }

    /// Adds one or more documents to an Amazon Q Business index. You use this API to:   ingest your structured and unstructured documents and documents stored in an Amazon S3 bucket into an Amazon Q Business index.   add custom attributes to documents in an Amazon Q Business index.   attach an access control list to the documents added to an Amazon Q Business index.   You can see the progress of the deletion, and any error messages related to the process, by using CloudWatch.
    @Sendable
    @inlinable
    public func batchPutDocument(_ input: BatchPutDocumentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchPutDocumentResponse {
        try await self.client.execute(
            operation: "BatchPutDocument", 
            path: "/applications/{applicationId}/indices/{indexId}/documents", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds one or more documents to an Amazon Q Business index. You use this API to:   ingest your structured and unstructured documents and documents stored in an Amazon S3 bucket into an Amazon Q Business index.   add custom attributes to documents in an Amazon Q Business index.   attach an access control list to the documents added to an Amazon Q Business index.   You can see the progress of the deletion, and any error messages related to the process, by using CloudWatch.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application.
    ///   - dataSourceSyncId: The identifier of the data source sync during which the documents were added.
    ///   - documents: One or more documents to add to the index.
    ///   - indexId: The identifier of the Amazon Q Business index to add the documents to.
    ///   - roleArn: The Amazon Resource Name (ARN) of an IAM role with permission to access your S3 bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchPutDocument(
        applicationId: String,
        dataSourceSyncId: String? = nil,
        documents: [Document],
        indexId: String,
        roleArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchPutDocumentResponse {
        let input = BatchPutDocumentRequest(
            applicationId: applicationId, 
            dataSourceSyncId: dataSourceSyncId, 
            documents: documents, 
            indexId: indexId, 
            roleArn: roleArn
        )
        return try await self.batchPutDocument(input, logger: logger)
    }

    /// Unsubscribes a user or a group from their pricing tier in an Amazon Q Business application. An unsubscribed user or group loses all Amazon Q Business feature access at the start of next month.
    @Sendable
    @inlinable
    public func cancelSubscription(_ input: CancelSubscriptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelSubscriptionResponse {
        try await self.client.execute(
            operation: "CancelSubscription", 
            path: "/applications/{applicationId}/subscriptions/{subscriptionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Unsubscribes a user or a group from their pricing tier in an Amazon Q Business application. An unsubscribed user or group loses all Amazon Q Business feature access at the start of next month.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application for which the subscription is being cancelled.
    ///   - subscriptionId: The identifier of the Amazon Q Business subscription being cancelled.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelSubscription(
        applicationId: String,
        subscriptionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelSubscriptionResponse {
        let input = CancelSubscriptionRequest(
            applicationId: applicationId, 
            subscriptionId: subscriptionId
        )
        return try await self.cancelSubscription(input, logger: logger)
    }

    /// Starts or continues a streaming Amazon Q Business conversation.
    @Sendable
    @inlinable
    public func chat(_ input: ChatInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ChatOutput {
        try await self.client.execute(
            operation: "Chat", 
            path: "/applications/{applicationId}/conversations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts or continues a streaming Amazon Q Business conversation.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application linked to a streaming Amazon Q Business conversation.
    ///   - clientToken: A token that you provide to identify the chat input.
    ///   - conversationId: The identifier of the Amazon Q Business conversation.
    ///   - inputStream: The streaming input for the Chat API.
    ///   - parentMessageId: The identifier used to associate a user message with a AI generated response.
    ///   - userGroups: The group names that a user associated with the chat input belongs to.
    ///   - userId: The identifier of the user attached to the chat input.
    ///   - logger: Logger use during operation
    @inlinable
    public func chat(
        applicationId: String,
        clientToken: String? = ChatInput.idempotencyToken(),
        conversationId: String? = nil,
        inputStream: AWSEventStream<ChatInputStream>? = nil,
        parentMessageId: String? = nil,
        userGroups: [String]? = nil,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ChatOutput {
        let input = ChatInput(
            applicationId: applicationId, 
            clientToken: clientToken, 
            conversationId: conversationId, 
            inputStream: inputStream, 
            parentMessageId: parentMessageId, 
            userGroups: userGroups, 
            userId: userId
        )
        return try await self.chat(input, logger: logger)
    }

    /// Starts or continues a non-streaming Amazon Q Business conversation.
    @Sendable
    @inlinable
    public func chatSync(_ input: ChatSyncInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ChatSyncOutput {
        try await self.client.execute(
            operation: "ChatSync", 
            path: "/applications/{applicationId}/conversations?sync", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts or continues a non-streaming Amazon Q Business conversation.
    ///
    /// Parameters:
    ///   - actionExecution: A request from an end user to perform an Amazon Q Business plugin action.
    ///   - applicationId: The identifier of the Amazon Q Business application linked to the Amazon Q Business conversation.
    ///   - attachments: A list of files uploaded directly during chat. You can upload a maximum of 5 files of upto 10 MB each.
    ///   - attributeFilter: Enables filtering of Amazon Q Business web experience responses based on document attributes or metadata fields.
    ///   - authChallengeResponse: An authentication verification event response by a third party authentication server to Amazon Q Business.
    ///   - chatMode: The chatMode parameter determines the chat modes available to Amazon Q Business users:    RETRIEVAL_MODE - If you choose this mode, Amazon Q generates responses solely from the data sources connected and indexed by the application. If an answer is not found in the data sources or there are no data sources available, Amazon Q will respond with a "No Answer Found" message, unless LLM knowledge has been enabled. In that case, Amazon Q will generate a response from the LLM knowledge    CREATOR_MODE - By selecting this mode, you can choose to generate responses only from the LLM knowledge. You can also attach files and have Amazon Q generate a response based on the data in those files. If the attached files do not contain an answer for the query, Amazon Q will automatically fall back to generating a response from the LLM knowledge.    PLUGIN_MODE - By selecting this mode, users can choose to use plugins in chat to get their responses.    If none of the modes are selected, Amazon Q will only respond using the information from the attached files.  For more information, see Admin controls and guardrails, Plugins, and Response sources.
    ///   - chatModeConfiguration: The chat mode configuration for an Amazon Q Business application.
    ///   - clientToken: A token that you provide to identify a chat request.
    ///   - conversationId: The identifier of the Amazon Q Business conversation.
    ///   - parentMessageId: The identifier of the previous system message in a conversation.
    ///   - userGroups: The group names that a user associated with the chat input belongs to.
    ///   - userId: The identifier of the user attached to the chat input.
    ///   - userMessage: A end user message in a conversation.
    ///   - logger: Logger use during operation
    @inlinable
    public func chatSync(
        actionExecution: ActionExecution? = nil,
        applicationId: String,
        attachments: [AttachmentInput]? = nil,
        attributeFilter: AttributeFilter? = nil,
        authChallengeResponse: AuthChallengeResponse? = nil,
        chatMode: ChatMode? = nil,
        chatModeConfiguration: ChatModeConfiguration? = nil,
        clientToken: String? = ChatSyncInput.idempotencyToken(),
        conversationId: String? = nil,
        parentMessageId: String? = nil,
        userGroups: [String]? = nil,
        userId: String? = nil,
        userMessage: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ChatSyncOutput {
        let input = ChatSyncInput(
            actionExecution: actionExecution, 
            applicationId: applicationId, 
            attachments: attachments, 
            attributeFilter: attributeFilter, 
            authChallengeResponse: authChallengeResponse, 
            chatMode: chatMode, 
            chatModeConfiguration: chatModeConfiguration, 
            clientToken: clientToken, 
            conversationId: conversationId, 
            parentMessageId: parentMessageId, 
            userGroups: userGroups, 
            userId: userId, 
            userMessage: userMessage
        )
        return try await self.chatSync(input, logger: logger)
    }

    /// Verifies if a user has access permissions for a specified document and returns the actual ACL attached to the document. Resolves user access on the document via user aliases and groups when verifying user access.
    @Sendable
    @inlinable
    public func checkDocumentAccess(_ input: CheckDocumentAccessRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CheckDocumentAccessResponse {
        try await self.client.execute(
            operation: "CheckDocumentAccess", 
            path: "/applications/{applicationId}/index/{indexId}/users/{userId}/documents/{documentId}/check-document-access", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Verifies if a user has access permissions for a specified document and returns the actual ACL attached to the document. Resolves user access on the document via user aliases and groups when verifying user access.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of the application. This is required to identify the specific Amazon Q Business application context for the document access check.
    ///   - dataSourceId: The unique identifier of the data source. Identifies the specific data source from which the document originates. Should not be used when a document is uploaded directly with BatchPutDocument, as no dataSourceId is available or necessary.
    ///   - documentId: The unique identifier of the document. Specifies which document's access permissions are being checked.
    ///   - indexId: The unique identifier of the index. Used to locate the correct index within the application where the document is stored.
    ///   - userId: The unique identifier of the user. Used to check the access permissions for this specific user against the document's ACL.
    ///   - logger: Logger use during operation
    @inlinable
    public func checkDocumentAccess(
        applicationId: String,
        dataSourceId: String? = nil,
        documentId: String,
        indexId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CheckDocumentAccessResponse {
        let input = CheckDocumentAccessRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            documentId: documentId, 
            indexId: indexId, 
            userId: userId
        )
        return try await self.checkDocumentAccess(input, logger: logger)
    }

    /// Creates a unique URL for anonymous Amazon Q Business web experience. This URL can only be used once and must be used within 5 minutes after it's generated.
    @Sendable
    @inlinable
    public func createAnonymousWebExperienceUrl(_ input: CreateAnonymousWebExperienceUrlRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAnonymousWebExperienceUrlResponse {
        try await self.client.execute(
            operation: "CreateAnonymousWebExperienceUrl", 
            path: "/applications/{applicationId}/experiences/{webExperienceId}/anonymous-url", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a unique URL for anonymous Amazon Q Business web experience. This URL can only be used once and must be used within 5 minutes after it's generated.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application environment attached to the web experience.
    ///   - sessionDurationInMinutes: The duration of the session associated with the unique URL for the web experience.
    ///   - webExperienceId: The identifier of the web experience.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAnonymousWebExperienceUrl(
        applicationId: String,
        sessionDurationInMinutes: Int? = nil,
        webExperienceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAnonymousWebExperienceUrlResponse {
        let input = CreateAnonymousWebExperienceUrlRequest(
            applicationId: applicationId, 
            sessionDurationInMinutes: sessionDurationInMinutes, 
            webExperienceId: webExperienceId
        )
        return try await self.createAnonymousWebExperienceUrl(input, logger: logger)
    }

    /// Creates an Amazon Q Business application.  There are new tiers for Amazon Q Business. Not all features in Amazon Q Business Pro are also available in Amazon Q Business Lite. For information on what's included in Amazon Q Business Lite and what's included in Amazon Q Business Pro, see Amazon Q Business tiers. You must use the Amazon Q Business console to assign subscription tiers to users.  An Amazon Q Apps service linked role will be created if it's absent in the Amazon Web Services account when QAppsConfiguration is enabled in the request. For more information, see  Using service-linked roles for Q Apps. When you create an application, Amazon Q Business may securely transmit data for processing from your selected Amazon Web Services region, but within your geography. For more information, see Cross region inference in Amazon Q Business.
    @Sendable
    @inlinable
    public func createApplication(_ input: CreateApplicationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateApplicationResponse {
        try await self.client.execute(
            operation: "CreateApplication", 
            path: "/applications", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q Business application.  There are new tiers for Amazon Q Business. Not all features in Amazon Q Business Pro are also available in Amazon Q Business Lite. For information on what's included in Amazon Q Business Lite and what's included in Amazon Q Business Pro, see Amazon Q Business tiers. You must use the Amazon Q Business console to assign subscription tiers to users.  An Amazon Q Apps service linked role will be created if it's absent in the Amazon Web Services account when QAppsConfiguration is enabled in the request. For more information, see  Using service-linked roles for Q Apps. When you create an application, Amazon Q Business may securely transmit data for processing from your selected Amazon Web Services region, but within your geography. For more information, see Cross region inference in Amazon Q Business.
    ///
    /// Parameters:
    ///   - attachmentsConfiguration: An option to allow end users to upload files directly during chat.
    ///   - clientIdsForOIDC: The OIDC client ID for a Amazon Q Business application.
    ///   - clientToken: A token that you provide to identify the request to create your Amazon Q Business application.
    ///   - description: A description for the Amazon Q Business application.
    ///   - displayName: A name for the Amazon Q Business application.
    ///   - encryptionConfiguration: The identifier of the KMS key that is used to encrypt your data. Amazon Q Business doesn't support asymmetric keys.
    ///   - iamIdentityProviderArn: The Amazon Resource Name (ARN) of an identity provider being used by an Amazon Q Business application.
    ///   - identityCenterInstanceArn:  The Amazon Resource Name (ARN) of the IAM Identity Center instance you are either creating for—or connecting to—your Amazon Q Business application.
    ///   - identityType: The authentication type being used by a Amazon Q Business application.
    ///   - personalizationConfiguration: Configuration information about chat response personalization. For more information, see Personalizing chat responses
    ///   - qAppsConfiguration: An option to allow end users to create and use Amazon Q Apps in the web experience.
    ///   - quickSightConfiguration: The Amazon QuickSight configuration for an Amazon Q Business application that uses QuickSight for authentication. This configuration is required if your application uses QuickSight as the identity provider. For more information, see Creating an Amazon QuickSight integrated application.
    ///   - roleArn:  The Amazon Resource Name (ARN) of an IAM role with permissions to access your Amazon CloudWatch logs and metrics. If this property is not specified, Amazon Q Business will create a service linked role (SLR) and use it as the application's role.
    ///   - tags: A list of key-value pairs that identify or categorize your Amazon Q Business application. You can also use tags to help control access to the application. Tag keys and values can consist of Unicode letters, digits, white space, and any of the following symbols: _ . : / = + - @.
    ///   - logger: Logger use during operation
    @inlinable
    public func createApplication(
        attachmentsConfiguration: AttachmentsConfiguration? = nil,
        clientIdsForOIDC: [String]? = nil,
        clientToken: String? = CreateApplicationRequest.idempotencyToken(),
        description: String? = nil,
        displayName: String,
        encryptionConfiguration: EncryptionConfiguration? = nil,
        iamIdentityProviderArn: String? = nil,
        identityCenterInstanceArn: String? = nil,
        identityType: IdentityType? = nil,
        personalizationConfiguration: PersonalizationConfiguration? = nil,
        qAppsConfiguration: QAppsConfiguration? = nil,
        quickSightConfiguration: QuickSightConfiguration? = nil,
        roleArn: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateApplicationResponse {
        let input = CreateApplicationRequest(
            attachmentsConfiguration: attachmentsConfiguration, 
            clientIdsForOIDC: clientIdsForOIDC, 
            clientToken: clientToken, 
            description: description, 
            displayName: displayName, 
            encryptionConfiguration: encryptionConfiguration, 
            iamIdentityProviderArn: iamIdentityProviderArn, 
            identityCenterInstanceArn: identityCenterInstanceArn, 
            identityType: identityType, 
            personalizationConfiguration: personalizationConfiguration, 
            qAppsConfiguration: qAppsConfiguration, 
            quickSightConfiguration: quickSightConfiguration, 
            roleArn: roleArn, 
            tags: tags
        )
        return try await self.createApplication(input, logger: logger)
    }

    /// Creates a new chat response configuration for an Amazon Q Business application. This operation establishes a set of parameters that define how the system generates and formats responses to user queries in chat interactions.
    @Sendable
    @inlinable
    public func createChatResponseConfiguration(_ input: CreateChatResponseConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateChatResponseConfigurationResponse {
        try await self.client.execute(
            operation: "CreateChatResponseConfiguration", 
            path: "/applications/{applicationId}/chatresponseconfigurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new chat response configuration for an Amazon Q Business application. This operation establishes a set of parameters that define how the system generates and formats responses to user queries in chat interactions.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application for which to create the new chat response configuration.
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request. This helps prevent the same configuration from being created multiple times if retries occur.
    ///   - displayName: A human-readable name for the new chat response configuration, making it easier to identify and manage among multiple configurations.
    ///   - responseConfigurations: A collection of response configuration settings that define how Amazon Q Business will generate and format responses to user queries in chat interactions.
    ///   - tags: A list of key-value pairs to apply as tags to the new chat response configuration, enabling categorization and management of resources across Amazon Web Services services.
    ///   - logger: Logger use during operation
    @inlinable
    public func createChatResponseConfiguration(
        applicationId: String,
        clientToken: String? = CreateChatResponseConfigurationRequest.idempotencyToken(),
        displayName: String,
        responseConfigurations: [ResponseConfigurationType: ResponseConfiguration],
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateChatResponseConfigurationResponse {
        let input = CreateChatResponseConfigurationRequest(
            applicationId: applicationId, 
            clientToken: clientToken, 
            displayName: displayName, 
            responseConfigurations: responseConfigurations, 
            tags: tags
        )
        return try await self.createChatResponseConfiguration(input, logger: logger)
    }

    /// Creates a new data accessor for an ISV to access data from a Amazon Q Business application. The data accessor is an entity that represents the ISV's access to the Amazon Q Business application's data. It includes the IAM role ARN for the ISV, a friendly name, and a set of action configurations that define the specific actions the ISV is allowed to perform and any associated data filters. When the data accessor is created, an IAM Identity Center application is also created to manage the ISV's identity and authentication for accessing the Amazon Q Business application.
    @Sendable
    @inlinable
    public func createDataAccessor(_ input: CreateDataAccessorRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDataAccessorResponse {
        try await self.client.execute(
            operation: "CreateDataAccessor", 
            path: "/applications/{applicationId}/dataaccessors", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new data accessor for an ISV to access data from a Amazon Q Business application. The data accessor is an entity that represents the ISV's access to the Amazon Q Business application's data. It includes the IAM role ARN for the ISV, a friendly name, and a set of action configurations that define the specific actions the ISV is allowed to perform and any associated data filters. When the data accessor is created, an IAM Identity Center application is also created to manage the ISV's identity and authentication for accessing the Amazon Q Business application.
    ///
    /// Parameters:
    ///   - actionConfigurations: A list of action configurations specifying the allowed actions and any associated filters.
    ///   - applicationId: The unique identifier of the Amazon Q Business application.
    ///   - authenticationDetail: The authentication configuration details for the data accessor. This specifies how the ISV will authenticate when accessing data through this data accessor.
    ///   - clientToken: A unique, case-sensitive identifier you provide to ensure idempotency of the request.
    ///   - displayName: A friendly name for the data accessor.
    ///   - principal: The Amazon Resource Name (ARN) of the IAM role for the ISV that will be accessing the data.
    ///   - tags: The tags to associate with the data accessor.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDataAccessor(
        actionConfigurations: [ActionConfiguration],
        applicationId: String,
        authenticationDetail: DataAccessorAuthenticationDetail? = nil,
        clientToken: String? = CreateDataAccessorRequest.idempotencyToken(),
        displayName: String,
        principal: String,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDataAccessorResponse {
        let input = CreateDataAccessorRequest(
            actionConfigurations: actionConfigurations, 
            applicationId: applicationId, 
            authenticationDetail: authenticationDetail, 
            clientToken: clientToken, 
            displayName: displayName, 
            principal: principal, 
            tags: tags
        )
        return try await self.createDataAccessor(input, logger: logger)
    }

    /// Creates a data source connector for an Amazon Q Business application.  CreateDataSource is a synchronous operation. The operation returns 200 if the data source was successfully created. Otherwise, an exception is raised.
    @Sendable
    @inlinable
    public func createDataSource(_ input: CreateDataSourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDataSourceResponse {
        try await self.client.execute(
            operation: "CreateDataSource", 
            path: "/applications/{applicationId}/indices/{indexId}/datasources", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a data source connector for an Amazon Q Business application.  CreateDataSource is a synchronous operation. The operation returns 200 if the data source was successfully created. Otherwise, an exception is raised.
    ///
    /// Parameters:
    ///   - applicationId:  The identifier of the Amazon Q Business application the data source will be attached to.
    ///   - clientToken: A token you provide to identify a request to create a data source connector. Multiple calls to the CreateDataSource API with the same client token will create only one data source connector.
    ///   - configuration: Configuration information to connect your data source repository to Amazon Q Business. Use this parameter to provide a JSON schema with configuration information specific to your data source connector. Each data source has a JSON schema provided by Amazon Q Business that you must use. For example, the Amazon S3 and Web Crawler connectors require the following JSON schemas:    Amazon S3 JSON schema     Web Crawler JSON schema    You can find configuration templates for your specific data source using the following steps:   Navigate to the Supported connectors page in the Amazon Q Business User Guide, and select the data source of your choice.   Then, from your specific data source connector page, select Using the API. You will find the JSON schema for your data source, including parameter descriptions, in this section.
    ///   - description: A description for the data source connector.
    ///   - displayName: A name for the data source connector.
    ///   - documentEnrichmentConfiguration: 
    ///   - indexId: The identifier of the index that you want to use with the data source connector.
    ///   - mediaExtractionConfiguration: The configuration for extracting information from media in documents during ingestion.
    ///   - roleArn: The Amazon Resource Name (ARN) of an IAM role with permission to access the data source and required resources.
    ///   - syncSchedule: Sets the frequency for Amazon Q Business to check the documents in your data source repository and update your index. If you don't set a schedule, Amazon Q Business won't periodically update the index. Specify a cron- format schedule string or an empty string to indicate that the index is updated on demand. You can't specify the Schedule parameter when the Type parameter is set to CUSTOM. If you do, you receive a ValidationException exception.
    ///   - tags: A list of key-value pairs that identify or categorize the data source connector. You can also use tags to help control access to the data source connector. Tag keys and values can consist of Unicode letters, digits, white space, and any of the following symbols: _ . : / = + - @.
    ///   - vpcConfiguration: Configuration information for an Amazon VPC (Virtual Private Cloud) to connect to your data source. For more information, see Using Amazon VPC with Amazon Q Business connectors.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDataSource(
        applicationId: String,
        clientToken: String? = CreateDataSourceRequest.idempotencyToken(),
        configuration: AWSDocument,
        description: String? = nil,
        displayName: String,
        documentEnrichmentConfiguration: DocumentEnrichmentConfiguration? = nil,
        indexId: String,
        mediaExtractionConfiguration: MediaExtractionConfiguration? = nil,
        roleArn: String? = nil,
        syncSchedule: String? = nil,
        tags: [Tag]? = nil,
        vpcConfiguration: DataSourceVpcConfiguration? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDataSourceResponse {
        let input = CreateDataSourceRequest(
            applicationId: applicationId, 
            clientToken: clientToken, 
            configuration: configuration, 
            description: description, 
            displayName: displayName, 
            documentEnrichmentConfiguration: documentEnrichmentConfiguration, 
            indexId: indexId, 
            mediaExtractionConfiguration: mediaExtractionConfiguration, 
            roleArn: roleArn, 
            syncSchedule: syncSchedule, 
            tags: tags, 
            vpcConfiguration: vpcConfiguration
        )
        return try await self.createDataSource(input, logger: logger)
    }

    /// Creates an Amazon Q Business index. To determine if index creation has completed, check the Status field returned from a call to DescribeIndex. The Status field is set to ACTIVE when the index is ready to use. Once the index is active, you can index your documents using the  BatchPutDocument  API or the  CreateDataSource  API.
    @Sendable
    @inlinable
    public func createIndex(_ input: CreateIndexRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateIndexResponse {
        try await self.client.execute(
            operation: "CreateIndex", 
            path: "/applications/{applicationId}/indices", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q Business index. To determine if index creation has completed, check the Status field returned from a call to DescribeIndex. The Status field is set to ACTIVE when the index is ready to use. Once the index is active, you can index your documents using the  BatchPutDocument  API or the  CreateDataSource  API.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application using the index.
    ///   - capacityConfiguration: The capacity units you want to provision for your index. You can add and remove capacity to fit your usage needs.
    ///   - clientToken: A token that you provide to identify the request to create an index. Multiple calls to the CreateIndex API with the same client token will create only one index.
    ///   - description: A description for the Amazon Q Business index.
    ///   - displayName: A name for the Amazon Q Business index.
    ///   - tags: A list of key-value pairs that identify or categorize the index. You can also use tags to help control access to the index. Tag keys and values can consist of Unicode letters, digits, white space, and any of the following symbols: _ . : / = + - @.
    ///   - type: The index type that's suitable for your needs. For more information on what's included in each type of index, see Amazon Q Business tiers.
    ///   - logger: Logger use during operation
    @inlinable
    public func createIndex(
        applicationId: String,
        capacityConfiguration: IndexCapacityConfiguration? = nil,
        clientToken: String? = CreateIndexRequest.idempotencyToken(),
        description: String? = nil,
        displayName: String,
        tags: [Tag]? = nil,
        type: IndexType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateIndexResponse {
        let input = CreateIndexRequest(
            applicationId: applicationId, 
            capacityConfiguration: capacityConfiguration, 
            clientToken: clientToken, 
            description: description, 
            displayName: displayName, 
            tags: tags, 
            type: type
        )
        return try await self.createIndex(input, logger: logger)
    }

    /// Creates an Amazon Q Business plugin.
    @Sendable
    @inlinable
    public func createPlugin(_ input: CreatePluginRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePluginResponse {
        try await self.client.execute(
            operation: "CreatePlugin", 
            path: "/applications/{applicationId}/plugins", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q Business plugin.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application that will contain the plugin.
    ///   - authConfiguration: 
    ///   - clientToken: A token that you provide to identify the request to create your Amazon Q Business plugin.
    ///   - customPluginConfiguration: Contains configuration for a custom plugin.
    ///   - displayName: A the name for your plugin.
    ///   - serverUrl: The source URL used for plugin configuration.
    ///   - tags: A list of key-value pairs that identify or categorize the data source connector. You can also use tags to help control access to the data source connector. Tag keys and values can consist of Unicode letters, digits, white space, and any of the following symbols: _ . : / = + - @.
    ///   - type: The type of plugin you want to create.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPlugin(
        applicationId: String,
        authConfiguration: PluginAuthConfiguration,
        clientToken: String? = CreatePluginRequest.idempotencyToken(),
        customPluginConfiguration: CustomPluginConfiguration? = nil,
        displayName: String,
        serverUrl: String? = nil,
        tags: [Tag]? = nil,
        type: PluginType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePluginResponse {
        let input = CreatePluginRequest(
            applicationId: applicationId, 
            authConfiguration: authConfiguration, 
            clientToken: clientToken, 
            customPluginConfiguration: customPluginConfiguration, 
            displayName: displayName, 
            serverUrl: serverUrl, 
            tags: tags, 
            type: type
        )
        return try await self.createPlugin(input, logger: logger)
    }

    /// Adds a retriever to your Amazon Q Business application.
    @Sendable
    @inlinable
    public func createRetriever(_ input: CreateRetrieverRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRetrieverResponse {
        try await self.client.execute(
            operation: "CreateRetriever", 
            path: "/applications/{applicationId}/retrievers", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds a retriever to your Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of your Amazon Q Business application.
    ///   - clientToken: A token that you provide to identify the request to create your Amazon Q Business application retriever.
    ///   - configuration: 
    ///   - displayName: The name of your retriever.
    ///   - roleArn: The ARN of an IAM role used by Amazon Q Business to access the basic authentication credentials stored in a Secrets Manager secret.
    ///   - tags: A list of key-value pairs that identify or categorize the retriever. You can also use tags to help control access to the retriever. Tag keys and values can consist of Unicode letters, digits, white space, and any of the following symbols: _ . : / = + - @.
    ///   - type: The type of retriever you are using.
    ///   - logger: Logger use during operation
    @inlinable
    public func createRetriever(
        applicationId: String,
        clientToken: String? = CreateRetrieverRequest.idempotencyToken(),
        configuration: RetrieverConfiguration,
        displayName: String,
        roleArn: String? = nil,
        tags: [Tag]? = nil,
        type: RetrieverType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRetrieverResponse {
        let input = CreateRetrieverRequest(
            applicationId: applicationId, 
            clientToken: clientToken, 
            configuration: configuration, 
            displayName: displayName, 
            roleArn: roleArn, 
            tags: tags, 
            type: type
        )
        return try await self.createRetriever(input, logger: logger)
    }

    /// Subscribes an IAM Identity Center user or a group to a pricing tier for an Amazon Q Business application. Amazon Q Business offers two subscription tiers: Q_LITE and Q_BUSINESS. Subscription tier determines feature access for the user. For more information on subscriptions and pricing tiers, see Amazon Q Business pricing.
    @Sendable
    @inlinable
    public func createSubscription(_ input: CreateSubscriptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSubscriptionResponse {
        try await self.client.execute(
            operation: "CreateSubscription", 
            path: "/applications/{applicationId}/subscriptions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Subscribes an IAM Identity Center user or a group to a pricing tier for an Amazon Q Business application. Amazon Q Business offers two subscription tiers: Q_LITE and Q_BUSINESS. Subscription tier determines feature access for the user. For more information on subscriptions and pricing tiers, see Amazon Q Business pricing.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application the subscription should be added to.
    ///   - clientToken: A token that you provide to identify the request to create a subscription for your Amazon Q Business application.
    ///   - principal: The IAM Identity Center UserId or GroupId of a user or group in the IAM Identity Center instance connected to the Amazon Q Business application.
    ///   - type: The type of Amazon Q Business subscription you want to create.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSubscription(
        applicationId: String,
        clientToken: String? = CreateSubscriptionRequest.idempotencyToken(),
        principal: SubscriptionPrincipal,
        type: SubscriptionType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSubscriptionResponse {
        let input = CreateSubscriptionRequest(
            applicationId: applicationId, 
            clientToken: clientToken, 
            principal: principal, 
            type: type
        )
        return try await self.createSubscription(input, logger: logger)
    }

    /// Creates a universally unique identifier (UUID) mapped to a list of local user ids within an application.
    @Sendable
    @inlinable
    public func createUser(_ input: CreateUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateUserResponse {
        try await self.client.execute(
            operation: "CreateUser", 
            path: "/applications/{applicationId}/users", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a universally unique identifier (UUID) mapped to a list of local user ids within an application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application for which the user mapping will be created.
    ///   - clientToken: A token that you provide to identify the request to create your Amazon Q Business user mapping.
    ///   - userAliases: The list of user aliases in the mapping.
    ///   - userId: The user emails attached to a user mapping.
    ///   - logger: Logger use during operation
    @inlinable
    public func createUser(
        applicationId: String,
        clientToken: String? = CreateUserRequest.idempotencyToken(),
        userAliases: [UserAlias]? = nil,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateUserResponse {
        let input = CreateUserRequest(
            applicationId: applicationId, 
            clientToken: clientToken, 
            userAliases: userAliases, 
            userId: userId
        )
        return try await self.createUser(input, logger: logger)
    }

    /// Creates an Amazon Q Business web experience.
    @Sendable
    @inlinable
    public func createWebExperience(_ input: CreateWebExperienceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWebExperienceResponse {
        try await self.client.execute(
            operation: "CreateWebExperience", 
            path: "/applications/{applicationId}/experiences", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Q Business web experience.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business web experience.
    ///   - browserExtensionConfiguration: The browser extension configuration for an Amazon Q Business web experience.   For Amazon Q Business application using external OIDC-compliant identity providers (IdPs). The IdP administrator must add the browser extension sign-in redirect URLs to the IdP application. For more information, see Configure external OIDC identity provider for your browser extensions..
    ///   - clientToken: A token you provide to identify a request to create an Amazon Q Business web experience.
    ///   - customizationConfiguration: Sets the custom logo, favicon, font, and color used in the Amazon Q web experience.
    ///   - identityProviderConfiguration: Information about the identity provider (IdP) used to authenticate end users of an Amazon Q Business web experience.
    ///   - origins: Sets the website domain origins that are allowed to embed the Amazon Q Business web experience. The domain origin refers to the base URL for accessing a website including the protocol (http/https), the domain name, and the port number (if specified).   You must only submit a base URL and not a full path. For example, https://docs.aws.amazon.com.
    ///   - roleArn: The Amazon Resource Name (ARN) of the service role attached to your web experience.  You must provide this value if you're using IAM Identity Center to manage end user access to your application. If you're using legacy identity management to manage user access, you don't need to provide this value.
    ///   - samplePromptsControlMode: Determines whether sample prompts are enabled in the web experience for an end user.
    ///   - subtitle: A subtitle to personalize your Amazon Q Business web experience.
    ///   - tags: A list of key-value pairs that identify or categorize your Amazon Q Business web experience. You can also use tags to help control access to the web experience. Tag keys and values can consist of Unicode letters, digits, white space, and any of the following symbols: _ . : / = + - @.
    ///   - title: The title for your Amazon Q Business web experience.
    ///   - welcomeMessage: The customized welcome message for end users of an Amazon Q Business web experience.
    ///   - logger: Logger use during operation
    @inlinable
    public func createWebExperience(
        applicationId: String,
        browserExtensionConfiguration: BrowserExtensionConfiguration? = nil,
        clientToken: String? = CreateWebExperienceRequest.idempotencyToken(),
        customizationConfiguration: CustomizationConfiguration? = nil,
        identityProviderConfiguration: IdentityProviderConfiguration? = nil,
        origins: [String]? = nil,
        roleArn: String? = nil,
        samplePromptsControlMode: WebExperienceSamplePromptsControlMode? = nil,
        subtitle: String? = nil,
        tags: [Tag]? = nil,
        title: String? = nil,
        welcomeMessage: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWebExperienceResponse {
        let input = CreateWebExperienceRequest(
            applicationId: applicationId, 
            browserExtensionConfiguration: browserExtensionConfiguration, 
            clientToken: clientToken, 
            customizationConfiguration: customizationConfiguration, 
            identityProviderConfiguration: identityProviderConfiguration, 
            origins: origins, 
            roleArn: roleArn, 
            samplePromptsControlMode: samplePromptsControlMode, 
            subtitle: subtitle, 
            tags: tags, 
            title: title, 
            welcomeMessage: welcomeMessage
        )
        return try await self.createWebExperience(input, logger: logger)
    }

    /// Deletes an Amazon Q Business application.
    @Sendable
    @inlinable
    public func deleteApplication(_ input: DeleteApplicationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteApplicationResponse {
        try await self.client.execute(
            operation: "DeleteApplication", 
            path: "/applications/{applicationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteApplication(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteApplicationResponse {
        let input = DeleteApplicationRequest(
            applicationId: applicationId
        )
        return try await self.deleteApplication(input, logger: logger)
    }

    /// Deletes an attachment associated with a specific Amazon Q Business conversation.
    @Sendable
    @inlinable
    public func deleteAttachment(_ input: DeleteAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAttachmentResponse {
        try await self.client.execute(
            operation: "DeleteAttachment", 
            path: "/applications/{applicationId}/conversations/{conversationId}/attachments/{attachmentId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an attachment associated with a specific Amazon Q Business conversation.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the Amazon Q Business application environment.
    ///   - attachmentId: The unique identifier for the attachment.
    ///   - conversationId: The unique identifier of the conversation.
    ///   - userId: The unique identifier of the user involved in the conversation.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAttachment(
        applicationId: String,
        attachmentId: String,
        conversationId: String,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAttachmentResponse {
        let input = DeleteAttachmentRequest(
            applicationId: applicationId, 
            attachmentId: attachmentId, 
            conversationId: conversationId, 
            userId: userId
        )
        return try await self.deleteAttachment(input, logger: logger)
    }

    /// Deletes chat controls configured for an existing Amazon Q Business application.
    @Sendable
    @inlinable
    public func deleteChatControlsConfiguration(_ input: DeleteChatControlsConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteChatControlsConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteChatControlsConfiguration", 
            path: "/applications/{applicationId}/chatcontrols", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes chat controls configured for an existing Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application the chat controls have been configured for.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteChatControlsConfiguration(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteChatControlsConfigurationResponse {
        let input = DeleteChatControlsConfigurationRequest(
            applicationId: applicationId
        )
        return try await self.deleteChatControlsConfiguration(input, logger: logger)
    }

    /// Deletes a specified chat response configuration from an Amazon Q Business application.
    @Sendable
    @inlinable
    public func deleteChatResponseConfiguration(_ input: DeleteChatResponseConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteChatResponseConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteChatResponseConfiguration", 
            path: "/applications/{applicationId}/chatresponseconfigurations/{chatResponseConfigurationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a specified chat response configuration from an Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of theAmazon Q Business application from which to delete the chat response configuration.
    ///   - chatResponseConfigurationId: The unique identifier of the chat response configuration to delete from the specified application.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteChatResponseConfiguration(
        applicationId: String,
        chatResponseConfigurationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteChatResponseConfigurationResponse {
        let input = DeleteChatResponseConfigurationRequest(
            applicationId: applicationId, 
            chatResponseConfigurationId: chatResponseConfigurationId
        )
        return try await self.deleteChatResponseConfiguration(input, logger: logger)
    }

    /// Deletes an Amazon Q Business web experience conversation.
    @Sendable
    @inlinable
    public func deleteConversation(_ input: DeleteConversationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteConversationResponse {
        try await self.client.execute(
            operation: "DeleteConversation", 
            path: "/applications/{applicationId}/conversations/{conversationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Q Business web experience conversation.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application associated with the conversation.
    ///   - conversationId: The identifier of the Amazon Q Business web experience conversation being deleted.
    ///   - userId: The identifier of the user who is deleting the conversation.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConversation(
        applicationId: String,
        conversationId: String,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteConversationResponse {
        let input = DeleteConversationRequest(
            applicationId: applicationId, 
            conversationId: conversationId, 
            userId: userId
        )
        return try await self.deleteConversation(input, logger: logger)
    }

    /// Deletes a specified data accessor. This operation permanently removes the data accessor and its associated IAM Identity Center application. Any access granted to the ISV through this data accessor will be revoked.
    @Sendable
    @inlinable
    public func deleteDataAccessor(_ input: DeleteDataAccessorRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteDataAccessorResponse {
        try await self.client.execute(
            operation: "DeleteDataAccessor", 
            path: "/applications/{applicationId}/dataaccessors/{dataAccessorId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a specified data accessor. This operation permanently removes the data accessor and its associated IAM Identity Center application. Any access granted to the ISV through this data accessor will be revoked.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application.
    ///   - dataAccessorId: The unique identifier of the data accessor to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDataAccessor(
        applicationId: String,
        dataAccessorId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDataAccessorResponse {
        let input = DeleteDataAccessorRequest(
            applicationId: applicationId, 
            dataAccessorId: dataAccessorId
        )
        return try await self.deleteDataAccessor(input, logger: logger)
    }

    /// Deletes an Amazon Q Business data source connector. While the data source is being deleted, the Status field returned by a call to the DescribeDataSource API is set to DELETING.
    @Sendable
    @inlinable
    public func deleteDataSource(_ input: DeleteDataSourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteDataSourceResponse {
        try await self.client.execute(
            operation: "DeleteDataSource", 
            path: "/applications/{applicationId}/indices/{indexId}/datasources/{dataSourceId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Q Business data source connector. While the data source is being deleted, the Status field returned by a call to the DescribeDataSource API is set to DELETING.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application used with the data source connector.
    ///   - dataSourceId: The identifier of the data source connector that you want to delete.
    ///   - indexId: The identifier of the index used with the data source connector.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDataSource(
        applicationId: String,
        dataSourceId: String,
        indexId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDataSourceResponse {
        let input = DeleteDataSourceRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            indexId: indexId
        )
        return try await self.deleteDataSource(input, logger: logger)
    }

    /// Deletes a group so that all users and sub groups that belong to the group can no longer access documents only available to that group. For example, after deleting the group "Summer Interns", all interns who belonged to that group no longer see intern-only documents in their chat results.  If you want to delete, update, or replace users or sub groups of a group, you need to use the PutGroup operation. For example, if a user in the group "Engineering" leaves the engineering team and another user takes their place, you provide an updated list of users or sub groups that belong to the "Engineering" group when calling PutGroup.
    @Sendable
    @inlinable
    public func deleteGroup(_ input: DeleteGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteGroupResponse {
        try await self.client.execute(
            operation: "DeleteGroup", 
            path: "/applications/{applicationId}/indices/{indexId}/groups/{groupName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a group so that all users and sub groups that belong to the group can no longer access documents only available to that group. For example, after deleting the group "Summer Interns", all interns who belonged to that group no longer see intern-only documents in their chat results.  If you want to delete, update, or replace users or sub groups of a group, you need to use the PutGroup operation. For example, if a user in the group "Engineering" leaves the engineering team and another user takes their place, you provide an updated list of users or sub groups that belong to the "Engineering" group when calling PutGroup.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application in which the group mapping belongs.
    ///   - dataSourceId: The identifier of the data source linked to the group A group can be tied to multiple data sources. You can delete a group from accessing documents in a certain data source. For example, the groups "Research", "Engineering", and "Sales and Marketing" are all tied to the company's documents stored in the data sources Confluence and Salesforce. You want to delete "Research" and "Engineering" groups from Salesforce, so that these groups cannot access customer-related documents stored in Salesforce. Only "Sales and Marketing" should access documents in the Salesforce data source.
    ///   - groupName: The name of the group you want to delete.
    ///   - indexId: The identifier of the index you want to delete the group from.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteGroup(
        applicationId: String,
        dataSourceId: String? = nil,
        groupName: String,
        indexId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteGroupResponse {
        let input = DeleteGroupRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            groupName: groupName, 
            indexId: indexId
        )
        return try await self.deleteGroup(input, logger: logger)
    }

    /// Deletes an Amazon Q Business index.
    @Sendable
    @inlinable
    public func deleteIndex(_ input: DeleteIndexRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteIndexResponse {
        try await self.client.execute(
            operation: "DeleteIndex", 
            path: "/applications/{applicationId}/indices/{indexId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Q Business index.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application the Amazon Q Business index is linked to.
    ///   - indexId: The identifier of the Amazon Q Business index.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteIndex(
        applicationId: String,
        indexId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteIndexResponse {
        let input = DeleteIndexRequest(
            applicationId: applicationId, 
            indexId: indexId
        )
        return try await self.deleteIndex(input, logger: logger)
    }

    /// Deletes an Amazon Q Business plugin.
    @Sendable
    @inlinable
    public func deletePlugin(_ input: DeletePluginRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeletePluginResponse {
        try await self.client.execute(
            operation: "DeletePlugin", 
            path: "/applications/{applicationId}/plugins/{pluginId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Q Business plugin.
    ///
    /// Parameters:
    ///   - applicationId: The identifier the application attached to the Amazon Q Business plugin.
    ///   - pluginId: The identifier of the plugin being deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePlugin(
        applicationId: String,
        pluginId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeletePluginResponse {
        let input = DeletePluginRequest(
            applicationId: applicationId, 
            pluginId: pluginId
        )
        return try await self.deletePlugin(input, logger: logger)
    }

    /// Deletes the retriever used by an Amazon Q Business application.
    @Sendable
    @inlinable
    public func deleteRetriever(_ input: DeleteRetrieverRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteRetrieverResponse {
        try await self.client.execute(
            operation: "DeleteRetriever", 
            path: "/applications/{applicationId}/retrievers/{retrieverId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the retriever used by an Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application using the retriever.
    ///   - retrieverId: The identifier of the retriever being deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRetriever(
        applicationId: String,
        retrieverId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteRetrieverResponse {
        let input = DeleteRetrieverRequest(
            applicationId: applicationId, 
            retrieverId: retrieverId
        )
        return try await self.deleteRetriever(input, logger: logger)
    }

    /// Deletes a user by email id.
    @Sendable
    @inlinable
    public func deleteUser(_ input: DeleteUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteUserResponse {
        try await self.client.execute(
            operation: "DeleteUser", 
            path: "/applications/{applicationId}/users/{userId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a user by email id.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application from which the user is being deleted.
    ///   - userId: The user email being deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteUser(
        applicationId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteUserResponse {
        let input = DeleteUserRequest(
            applicationId: applicationId, 
            userId: userId
        )
        return try await self.deleteUser(input, logger: logger)
    }

    /// Deletes an Amazon Q Business web experience.
    @Sendable
    @inlinable
    public func deleteWebExperience(_ input: DeleteWebExperienceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteWebExperienceResponse {
        try await self.client.execute(
            operation: "DeleteWebExperience", 
            path: "/applications/{applicationId}/experiences/{webExperienceId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Q Business web experience.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application linked to the Amazon Q Business web experience.
    ///   - webExperienceId: The identifier of the Amazon Q Business web experience being deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWebExperience(
        applicationId: String,
        webExperienceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteWebExperienceResponse {
        let input = DeleteWebExperienceRequest(
            applicationId: applicationId, 
            webExperienceId: webExperienceId
        )
        return try await self.deleteWebExperience(input, logger: logger)
    }

    /// Removes a permission policy from a Amazon Q Business application, revoking the cross-account access that was previously granted to an ISV. This operation deletes the specified policy statement from the application's permission policy.
    @Sendable
    @inlinable
    public func disassociatePermission(_ input: DisassociatePermissionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociatePermissionResponse {
        try await self.client.execute(
            operation: "DisassociatePermission", 
            path: "/applications/{applicationId}/policy/{statementId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a permission policy from a Amazon Q Business application, revoking the cross-account access that was previously granted to an ISV. This operation deletes the specified policy statement from the application's permission policy.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application.
    ///   - statementId: The statement ID of the permission to remove.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociatePermission(
        applicationId: String,
        statementId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociatePermissionResponse {
        let input = DisassociatePermissionRequest(
            applicationId: applicationId, 
            statementId: statementId
        )
        return try await self.disassociatePermission(input, logger: logger)
    }

    /// Gets information about an existing Amazon Q Business application.
    @Sendable
    @inlinable
    public func getApplication(_ input: GetApplicationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetApplicationResponse {
        try await self.client.execute(
            operation: "GetApplication", 
            path: "/applications/{applicationId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about an existing Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApplication(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetApplicationResponse {
        let input = GetApplicationRequest(
            applicationId: applicationId
        )
        return try await self.getApplication(input, logger: logger)
    }

    /// Gets information about chat controls configured for an existing Amazon Q Business application.
    @Sendable
    @inlinable
    public func getChatControlsConfiguration(_ input: GetChatControlsConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetChatControlsConfigurationResponse {
        try await self.client.execute(
            operation: "GetChatControlsConfiguration", 
            path: "/applications/{applicationId}/chatcontrols", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about chat controls configured for an existing Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application for which the chat controls are configured.
    ///   - maxResults: The maximum number of configured chat controls to return.
    ///   - nextToken: If the maxResults response was incomplete because there is more data to retrieve, Amazon Q Business returns a pagination token in the response. You can use this pagination token to retrieve the next set of Amazon Q Business chat controls configured.
    ///   - logger: Logger use during operation
    @inlinable
    public func getChatControlsConfiguration(
        applicationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetChatControlsConfigurationResponse {
        let input = GetChatControlsConfigurationRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getChatControlsConfiguration(input, logger: logger)
    }

    /// Retrieves detailed information about a specific chat response configuration from an Amazon Q Business application. This operation returns the complete configuration settings and metadata.
    @Sendable
    @inlinable
    public func getChatResponseConfiguration(_ input: GetChatResponseConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetChatResponseConfigurationResponse {
        try await self.client.execute(
            operation: "GetChatResponseConfiguration", 
            path: "/applications/{applicationId}/chatresponseconfigurations/{chatResponseConfigurationId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves detailed information about a specific chat response configuration from an Amazon Q Business application. This operation returns the complete configuration settings and metadata.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application containing the chat response configuration to retrieve.
    ///   - chatResponseConfigurationId: The unique identifier of the chat response configuration to retrieve from the specified application.
    ///   - logger: Logger use during operation
    @inlinable
    public func getChatResponseConfiguration(
        applicationId: String,
        chatResponseConfigurationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetChatResponseConfigurationResponse {
        let input = GetChatResponseConfigurationRequest(
            applicationId: applicationId, 
            chatResponseConfigurationId: chatResponseConfigurationId
        )
        return try await self.getChatResponseConfiguration(input, logger: logger)
    }

    /// Retrieves information about a specified data accessor. This operation returns details about the data accessor, including its display name, unique identifier, Amazon Resource Name (ARN), the associated Amazon Q Business application and IAM Identity Center application, the IAM role for the ISV, the action configurations, and the timestamps for when the data accessor was created and last updated.
    @Sendable
    @inlinable
    public func getDataAccessor(_ input: GetDataAccessorRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDataAccessorResponse {
        try await self.client.execute(
            operation: "GetDataAccessor", 
            path: "/applications/{applicationId}/dataaccessors/{dataAccessorId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a specified data accessor. This operation returns details about the data accessor, including its display name, unique identifier, Amazon Resource Name (ARN), the associated Amazon Q Business application and IAM Identity Center application, the IAM role for the ISV, the action configurations, and the timestamps for when the data accessor was created and last updated.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application.
    ///   - dataAccessorId: The unique identifier of the data accessor to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDataAccessor(
        applicationId: String,
        dataAccessorId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDataAccessorResponse {
        let input = GetDataAccessorRequest(
            applicationId: applicationId, 
            dataAccessorId: dataAccessorId
        )
        return try await self.getDataAccessor(input, logger: logger)
    }

    /// Gets information about an existing Amazon Q Business data source connector.
    @Sendable
    @inlinable
    public func getDataSource(_ input: GetDataSourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDataSourceResponse {
        try await self.client.execute(
            operation: "GetDataSource", 
            path: "/applications/{applicationId}/indices/{indexId}/datasources/{dataSourceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about an existing Amazon Q Business data source connector.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application.
    ///   - dataSourceId: The identifier of the data source connector.
    ///   - indexId: The identfier of the index used with the data source connector.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDataSource(
        applicationId: String,
        dataSourceId: String,
        indexId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDataSourceResponse {
        let input = GetDataSourceRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            indexId: indexId
        )
        return try await self.getDataSource(input, logger: logger)
    }

    /// Describes a group by group name.
    @Sendable
    @inlinable
    public func getGroup(_ input: GetGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetGroupResponse {
        try await self.client.execute(
            operation: "GetGroup", 
            path: "/applications/{applicationId}/indices/{indexId}/groups/{groupName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes a group by group name.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application id the group is attached to.
    ///   - dataSourceId: The identifier of the data source the group is attached to.
    ///   - groupName: The name of the group.
    ///   - indexId: The identifier of the index the group is attached to.
    ///   - logger: Logger use during operation
    @inlinable
    public func getGroup(
        applicationId: String,
        dataSourceId: String? = nil,
        groupName: String,
        indexId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetGroupResponse {
        let input = GetGroupRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            groupName: groupName, 
            indexId: indexId
        )
        return try await self.getGroup(input, logger: logger)
    }

    /// Gets information about an existing Amazon Q Business index.
    @Sendable
    @inlinable
    public func getIndex(_ input: GetIndexRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetIndexResponse {
        try await self.client.execute(
            operation: "GetIndex", 
            path: "/applications/{applicationId}/indices/{indexId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about an existing Amazon Q Business index.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application connected to the index.
    ///   - indexId: The identifier of the Amazon Q Business index you want information on.
    ///   - logger: Logger use during operation
    @inlinable
    public func getIndex(
        applicationId: String,
        indexId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetIndexResponse {
        let input = GetIndexRequest(
            applicationId: applicationId, 
            indexId: indexId
        )
        return try await self.getIndex(input, logger: logger)
    }

    /// Returns the image bytes corresponding to a media object. If you have implemented your own application with the Chat and ChatSync APIs, and have enabled content extraction from visual data in Amazon Q Business, you use the GetMedia API operation to download the images so you can show them in your UI with responses. For more information, see Extracting semantic meaning from images and visuals.
    @Sendable
    @inlinable
    public func getMedia(_ input: GetMediaRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMediaResponse {
        try await self.client.execute(
            operation: "GetMedia", 
            path: "/applications/{applicationId}/conversations/{conversationId}/messages/{messageId}/media/{mediaId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the image bytes corresponding to a media object. If you have implemented your own application with the Chat and ChatSync APIs, and have enabled content extraction from visual data in Amazon Q Business, you use the GetMedia API operation to download the images so you can show them in your UI with responses. For more information, see Extracting semantic meaning from images and visuals.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business which contains the media object.
    ///   - conversationId: The identifier of the Amazon Q Business conversation.
    ///   - mediaId: The identifier of the media object. You can find this in the sourceAttributions returned by the Chat, ChatSync, and ListMessages API responses.
    ///   - messageId: The identifier of the Amazon Q Business message.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMedia(
        applicationId: String,
        conversationId: String,
        mediaId: String,
        messageId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMediaResponse {
        let input = GetMediaRequest(
            applicationId: applicationId, 
            conversationId: conversationId, 
            mediaId: mediaId, 
            messageId: messageId
        )
        return try await self.getMedia(input, logger: logger)
    }

    /// Gets information about an existing Amazon Q Business plugin.
    @Sendable
    @inlinable
    public func getPlugin(_ input: GetPluginRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPluginResponse {
        try await self.client.execute(
            operation: "GetPlugin", 
            path: "/applications/{applicationId}/plugins/{pluginId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about an existing Amazon Q Business plugin.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application which contains the plugin.
    ///   - pluginId: The identifier of the plugin.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPlugin(
        applicationId: String,
        pluginId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPluginResponse {
        let input = GetPluginRequest(
            applicationId: applicationId, 
            pluginId: pluginId
        )
        return try await self.getPlugin(input, logger: logger)
    }

    /// Retrieves the current permission policy for a Amazon Q Business application. The policy is returned as a JSON-formatted string and defines the IAM actions that are allowed or denied for the application's resources.
    @Sendable
    @inlinable
    public func getPolicy(_ input: GetPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPolicyResponse {
        try await self.client.execute(
            operation: "GetPolicy", 
            path: "/applications/{applicationId}/policy", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the current permission policy for a Amazon Q Business application. The policy is returned as a JSON-formatted string and defines the IAM actions that are allowed or denied for the application's resources.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPolicy(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPolicyResponse {
        let input = GetPolicyRequest(
            applicationId: applicationId
        )
        return try await self.getPolicy(input, logger: logger)
    }

    /// Gets information about an existing retriever used by an Amazon Q Business application.
    @Sendable
    @inlinable
    public func getRetriever(_ input: GetRetrieverRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRetrieverResponse {
        try await self.client.execute(
            operation: "GetRetriever", 
            path: "/applications/{applicationId}/retrievers/{retrieverId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about an existing retriever used by an Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application using the retriever.
    ///   - retrieverId: The identifier of the retriever.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRetriever(
        applicationId: String,
        retrieverId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRetrieverResponse {
        let input = GetRetrieverRequest(
            applicationId: applicationId, 
            retrieverId: retrieverId
        )
        return try await self.getRetriever(input, logger: logger)
    }

    /// Describes the universally unique identifier (UUID) associated with a local user in a data source.
    @Sendable
    @inlinable
    public func getUser(_ input: GetUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUserResponse {
        try await self.client.execute(
            operation: "GetUser", 
            path: "/applications/{applicationId}/users/{userId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the universally unique identifier (UUID) associated with a local user in a data source.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application connected to the user.
    ///   - userId: The user email address attached to the user.
    ///   - logger: Logger use during operation
    @inlinable
    public func getUser(
        applicationId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUserResponse {
        let input = GetUserRequest(
            applicationId: applicationId, 
            userId: userId
        )
        return try await self.getUser(input, logger: logger)
    }

    /// Gets information about an existing Amazon Q Business web experience.
    @Sendable
    @inlinable
    public func getWebExperience(_ input: GetWebExperienceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWebExperienceResponse {
        try await self.client.execute(
            operation: "GetWebExperience", 
            path: "/applications/{applicationId}/experiences/{webExperienceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about an existing Amazon Q Business web experience.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application linked to the web experience.
    ///   - webExperienceId: The identifier of the Amazon Q Business web experience.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWebExperience(
        applicationId: String,
        webExperienceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWebExperienceResponse {
        let input = GetWebExperienceRequest(
            applicationId: applicationId, 
            webExperienceId: webExperienceId
        )
        return try await self.getWebExperience(input, logger: logger)
    }

    /// Lists Amazon Q Business applications.  Amazon Q Business applications may securely transmit data for processing across Amazon Web Services Regions within your geography. For more information, see Cross region inference in Amazon Q Business.
    @Sendable
    @inlinable
    public func listApplications(_ input: ListApplicationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListApplicationsResponse {
        try await self.client.execute(
            operation: "ListApplications", 
            path: "/applications", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists Amazon Q Business applications.  Amazon Q Business applications may securely transmit data for processing across Amazon Web Services Regions within your geography. For more information, see Cross region inference in Amazon Q Business.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of Amazon Q Business applications to return.
    ///   - nextToken: If the maxResults response was incomplete because there is more data to retrieve, Amazon Q Business returns a pagination token in the response. You can use this pagination token to retrieve the next set of Amazon Q Business applications.
    ///   - logger: Logger use during operation
    @inlinable
    public func listApplications(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListApplicationsResponse {
        let input = ListApplicationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listApplications(input, logger: logger)
    }

    /// Gets a list of attachments associated with an Amazon Q Business web experience or a list of attachements associated with a specific Amazon Q Business conversation.
    @Sendable
    @inlinable
    public func listAttachments(_ input: ListAttachmentsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAttachmentsResponse {
        try await self.client.execute(
            operation: "ListAttachments", 
            path: "/applications/{applicationId}/attachments", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a list of attachments associated with an Amazon Q Business web experience or a list of attachements associated with a specific Amazon Q Business conversation.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the Amazon Q Business application.
    ///   - conversationId: The unique identifier of the Amazon Q Business web experience conversation.
    ///   - maxResults: The maximum number of attachements to return.
    ///   - nextToken: If the number of attachments returned exceeds maxResults, Amazon Q Business returns a next token as a pagination token to retrieve the next set of attachments.
    ///   - userId: The unique identifier of the user involved in the Amazon Q Business web experience conversation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAttachments(
        applicationId: String,
        conversationId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAttachmentsResponse {
        let input = ListAttachmentsRequest(
            applicationId: applicationId, 
            conversationId: conversationId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            userId: userId
        )
        return try await self.listAttachments(input, logger: logger)
    }

    /// Retrieves a list of all chat response configurations available in a specified Amazon Q Business application. This operation returns summary information about each configuration to help administrators manage and select appropriate response settings.
    @Sendable
    @inlinable
    public func listChatResponseConfigurations(_ input: ListChatResponseConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListChatResponseConfigurationsResponse {
        try await self.client.execute(
            operation: "ListChatResponseConfigurations", 
            path: "/applications/{applicationId}/chatresponseconfigurations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of all chat response configurations available in a specified Amazon Q Business application. This operation returns summary information about each configuration to help administrators manage and select appropriate response settings.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application for which to list available chat response configurations.
    ///   - maxResults: The maximum number of chat response configurations to return in a single response. This parameter helps control pagination of results when many configurations exist.
    ///   - nextToken: A pagination token used to retrieve the next set of results when the number of configurations exceeds the specified maxResults value.
    ///   - logger: Logger use during operation
    @inlinable
    public func listChatResponseConfigurations(
        applicationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListChatResponseConfigurationsResponse {
        let input = ListChatResponseConfigurationsRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listChatResponseConfigurations(input, logger: logger)
    }

    /// Lists one or more Amazon Q Business conversations.
    @Sendable
    @inlinable
    public func listConversations(_ input: ListConversationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListConversationsResponse {
        try await self.client.execute(
            operation: "ListConversations", 
            path: "/applications/{applicationId}/conversations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists one or more Amazon Q Business conversations.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application.
    ///   - maxResults: The maximum number of Amazon Q Business conversations to return.
    ///   - nextToken: If the maxResults response was incomplete because there is more data to retrieve, Amazon Q Business returns a pagination token in the response. You can use this pagination token to retrieve the next set of Amazon Q Business conversations.
    ///   - userId: The identifier of the user involved in the Amazon Q Business web experience conversation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listConversations(
        applicationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListConversationsResponse {
        let input = ListConversationsRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            userId: userId
        )
        return try await self.listConversations(input, logger: logger)
    }

    /// Lists the data accessors for a Amazon Q Business application. This operation returns a paginated list of data accessor summaries, including the friendly name, unique identifier, ARN, associated IAM role, and creation/update timestamps for each data accessor.
    @Sendable
    @inlinable
    public func listDataAccessors(_ input: ListDataAccessorsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDataAccessorsResponse {
        try await self.client.execute(
            operation: "ListDataAccessors", 
            path: "/applications/{applicationId}/dataaccessors", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the data accessors for a Amazon Q Business application. This operation returns a paginated list of data accessor summaries, including the friendly name, unique identifier, ARN, associated IAM role, and creation/update timestamps for each data accessor.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application.
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - nextToken: The token for the next set of results. (You received this token from a previous call.)
    ///   - logger: Logger use during operation
    @inlinable
    public func listDataAccessors(
        applicationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDataAccessorsResponse {
        let input = ListDataAccessorsRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDataAccessors(input, logger: logger)
    }

    /// Get information about an Amazon Q Business data source connector synchronization.
    @Sendable
    @inlinable
    public func listDataSourceSyncJobs(_ input: ListDataSourceSyncJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDataSourceSyncJobsResponse {
        try await self.client.execute(
            operation: "ListDataSourceSyncJobs", 
            path: "/applications/{applicationId}/indices/{indexId}/datasources/{dataSourceId}/syncjobs", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get information about an Amazon Q Business data source connector synchronization.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application connected to the data source.
    ///   - dataSourceId:  The identifier of the data source connector.
    ///   - endTime:  The end time of the data source connector sync.
    ///   - indexId: The identifier of the index used with the Amazon Q Business data source connector.
    ///   - maxResults: The maximum number of synchronization jobs to return in the response.
    ///   - nextToken: If the maxResults response was incpmplete because there is more data to retriever, Amazon Q Business returns a pagination token in the response. You can use this pagination token to retrieve the next set of responses.
    ///   - startTime:  The start time of the data source connector sync.
    ///   - statusFilter: Only returns synchronization jobs with the Status field equal to the specified status.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDataSourceSyncJobs(
        applicationId: String,
        dataSourceId: String,
        endTime: Date? = nil,
        indexId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        startTime: Date? = nil,
        statusFilter: DataSourceSyncJobStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDataSourceSyncJobsResponse {
        let input = ListDataSourceSyncJobsRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            endTime: endTime, 
            indexId: indexId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            startTime: startTime, 
            statusFilter: statusFilter
        )
        return try await self.listDataSourceSyncJobs(input, logger: logger)
    }

    /// Lists the Amazon Q Business data source connectors that you have created.
    @Sendable
    @inlinable
    public func listDataSources(_ input: ListDataSourcesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDataSourcesResponse {
        try await self.client.execute(
            operation: "ListDataSources", 
            path: "/applications/{applicationId}/indices/{indexId}/datasources", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the Amazon Q Business data source connectors that you have created.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application linked to the data source connectors.
    ///   - indexId: The identifier of the index used with one or more data source connectors.
    ///   - maxResults: The maximum number of data source connectors to return.
    ///   - nextToken: If the maxResults response was incomplete because there is more data to retrieve, Amazon Q Business returns a pagination token in the response. You can use this pagination token to retrieve the next set of Amazon Q Business data source connectors.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDataSources(
        applicationId: String,
        indexId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDataSourcesResponse {
        let input = ListDataSourcesRequest(
            applicationId: applicationId, 
            indexId: indexId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDataSources(input, logger: logger)
    }

    /// A list of documents attached to an index.
    @Sendable
    @inlinable
    public func listDocuments(_ input: ListDocumentsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDocumentsResponse {
        try await self.client.execute(
            operation: "ListDocuments", 
            path: "/applications/{applicationId}/index/{indexId}/documents", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// A list of documents attached to an index.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application id the documents are attached to.
    ///   - dataSourceIds: The identifier of the data sources the documents are attached to.
    ///   - indexId: The identifier of the index the documents are attached to.
    ///   - maxResults: The maximum number of documents to return.
    ///   - nextToken: If the maxResults response was incomplete because there is more data to retrieve, Amazon Q Business returns a pagination token in the response. You can use this pagination token to retrieve the next set of documents.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDocuments(
        applicationId: String,
        dataSourceIds: [String]? = nil,
        indexId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDocumentsResponse {
        let input = ListDocumentsRequest(
            applicationId: applicationId, 
            dataSourceIds: dataSourceIds, 
            indexId: indexId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDocuments(input, logger: logger)
    }

    /// Provides a list of groups that are mapped to users.
    @Sendable
    @inlinable
    public func listGroups(_ input: ListGroupsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListGroupsResponse {
        try await self.client.execute(
            operation: "ListGroups", 
            path: "/applications/{applicationId}/indices/{indexId}/groups", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides a list of groups that are mapped to users.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application for getting a list of groups mapped to users.
    ///   - dataSourceId: The identifier of the data source for getting a list of groups mapped to users.
    ///   - indexId: The identifier of the index for getting a list of groups mapped to users.
    ///   - maxResults: The maximum number of returned groups that are mapped to users.
    ///   - nextToken: If the previous response was incomplete (because there is more data to retrieve), Amazon Q Business returns a pagination token in the response. You can use this pagination token to retrieve the next set of groups that are mapped to users.
    ///   - updatedEarlierThan: The timestamp identifier used for the latest PUT or DELETE action for mapping users to their groups.
    ///   - logger: Logger use during operation
    @inlinable
    public func listGroups(
        applicationId: String,
        dataSourceId: String? = nil,
        indexId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        updatedEarlierThan: Date,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListGroupsResponse {
        let input = ListGroupsRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            indexId: indexId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            updatedEarlierThan: updatedEarlierThan
        )
        return try await self.listGroups(input, logger: logger)
    }

    /// Lists the Amazon Q Business indices you have created.
    @Sendable
    @inlinable
    public func listIndices(_ input: ListIndicesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListIndicesResponse {
        try await self.client.execute(
            operation: "ListIndices", 
            path: "/applications/{applicationId}/indices", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the Amazon Q Business indices you have created.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application connected to the index.
    ///   - maxResults: The maximum number of indices to return.
    ///   - nextToken: If the maxResults response was incomplete because there is more data to retrieve, Amazon Q Business returns a pagination token in the response. You can use this pagination token to retrieve the next set of Amazon Q Business indices.
    ///   - logger: Logger use during operation
    @inlinable
    public func listIndices(
        applicationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListIndicesResponse {
        let input = ListIndicesRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listIndices(input, logger: logger)
    }

    /// Gets a list of messages associated with an Amazon Q Business web experience.
    @Sendable
    @inlinable
    public func listMessages(_ input: ListMessagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMessagesResponse {
        try await self.client.execute(
            operation: "ListMessages", 
            path: "/applications/{applicationId}/conversations/{conversationId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a list of messages associated with an Amazon Q Business web experience.
    ///
    /// Parameters:
    ///   - applicationId: The identifier for the Amazon Q Business application.
    ///   - conversationId: The identifier of the Amazon Q Business web experience conversation.
    ///   - maxResults: The maximum number of messages to return.
    ///   - nextToken: If the number of messages returned exceeds maxResults, Amazon Q Business returns a next token as a pagination token to retrieve the next set of messages.
    ///   - userId: The identifier of the user involved in the Amazon Q Business web experience conversation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMessages(
        applicationId: String,
        conversationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMessagesResponse {
        let input = ListMessagesRequest(
            applicationId: applicationId, 
            conversationId: conversationId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            userId: userId
        )
        return try await self.listMessages(input, logger: logger)
    }

    /// Lists configured Amazon Q Business actions for a specific plugin in an Amazon Q Business application.
    @Sendable
    @inlinable
    public func listPluginActions(_ input: ListPluginActionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPluginActionsResponse {
        try await self.client.execute(
            operation: "ListPluginActions", 
            path: "/applications/{applicationId}/plugins/{pluginId}/actions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists configured Amazon Q Business actions for a specific plugin in an Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application the plugin is attached to.
    ///   - maxResults: The maximum number of plugin actions to return.
    ///   - nextToken: If the number of plugin actions returned exceeds maxResults, Amazon Q Business returns a next token as a pagination token to retrieve the next set of plugin actions.
    ///   - pluginId: The identifier of the Amazon Q Business plugin.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPluginActions(
        applicationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        pluginId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPluginActionsResponse {
        let input = ListPluginActionsRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            pluginId: pluginId
        )
        return try await self.listPluginActions(input, logger: logger)
    }

    /// Lists configured Amazon Q Business actions for any plugin type—both built-in and custom.
    @Sendable
    @inlinable
    public func listPluginTypeActions(_ input: ListPluginTypeActionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPluginTypeActionsResponse {
        try await self.client.execute(
            operation: "ListPluginTypeActions", 
            path: "/pluginTypes/{pluginType}/actions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists configured Amazon Q Business actions for any plugin type—both built-in and custom.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of plugins to return.
    ///   - nextToken: If the number of plugins returned exceeds maxResults, Amazon Q Business returns a next token as a pagination token to retrieve the next set of plugins.
    ///   - pluginType: The type of the plugin.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPluginTypeActions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        pluginType: PluginType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPluginTypeActionsResponse {
        let input = ListPluginTypeActionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            pluginType: pluginType
        )
        return try await self.listPluginTypeActions(input, logger: logger)
    }

    /// Lists metadata for all Amazon Q Business plugin types.
    @Sendable
    @inlinable
    public func listPluginTypeMetadata(_ input: ListPluginTypeMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPluginTypeMetadataResponse {
        try await self.client.execute(
            operation: "ListPluginTypeMetadata", 
            path: "/pluginTypeMetadata", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists metadata for all Amazon Q Business plugin types.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of plugin metadata items to return.
    ///   - nextToken: If the metadata returned exceeds maxResults, Amazon Q Business returns a next token as a pagination token to retrieve the next set of metadata.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPluginTypeMetadata(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPluginTypeMetadataResponse {
        let input = ListPluginTypeMetadataRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listPluginTypeMetadata(input, logger: logger)
    }

    /// Lists configured Amazon Q Business plugins.
    @Sendable
    @inlinable
    public func listPlugins(_ input: ListPluginsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPluginsResponse {
        try await self.client.execute(
            operation: "ListPlugins", 
            path: "/applications/{applicationId}/plugins", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists configured Amazon Q Business plugins.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application the plugin is attached to.
    ///   - maxResults: The maximum number of documents to return.
    ///   - nextToken: If the maxResults response was incomplete because there is more data to retrieve, Amazon Q Business returns a pagination token in the response. You can use this pagination token to retrieve the next set of plugins.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPlugins(
        applicationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPluginsResponse {
        let input = ListPluginsRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listPlugins(input, logger: logger)
    }

    /// Lists the retriever used by an Amazon Q Business application.
    @Sendable
    @inlinable
    public func listRetrievers(_ input: ListRetrieversRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRetrieversResponse {
        try await self.client.execute(
            operation: "ListRetrievers", 
            path: "/applications/{applicationId}/retrievers", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the retriever used by an Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application using the retriever.
    ///   - maxResults: The maximum number of retrievers returned.
    ///   - nextToken: If the number of retrievers returned exceeds maxResults, Amazon Q Business returns a next token as a pagination token to retrieve the next set of retrievers.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRetrievers(
        applicationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRetrieversResponse {
        let input = ListRetrieversRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listRetrievers(input, logger: logger)
    }

    ///  Lists all subscriptions created in an Amazon Q Business application.
    @Sendable
    @inlinable
    public func listSubscriptions(_ input: ListSubscriptionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSubscriptionsResponse {
        try await self.client.execute(
            operation: "ListSubscriptions", 
            path: "/applications/{applicationId}/subscriptions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Lists all subscriptions created in an Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application linked to the subscription.
    ///   - maxResults: The maximum number of Amazon Q Business subscriptions to return.
    ///   - nextToken: If the maxResults response was incomplete because there is more data to retrieve, Amazon Q Business returns a pagination token in the response. You can use this pagination token to retrieve the next set of Amazon Q Business subscriptions.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSubscriptions(
        applicationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSubscriptionsResponse {
        let input = ListSubscriptionsRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSubscriptions(input, logger: logger)
    }

    /// Gets a list of tags associated with a specified resource. Amazon Q Business applications and data sources can have tags associated with them.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/v1/tags/{resourceARN}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a list of tags associated with a specified resource. Amazon Q Business applications and data sources can have tags associated with them.
    ///
    /// Parameters:
    ///   - resourceARN: The Amazon Resource Name (ARN) of the Amazon Q Business application or data source to get a list of tags for.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceARN: resourceARN
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Lists one or more Amazon Q Business Web Experiences.
    @Sendable
    @inlinable
    public func listWebExperiences(_ input: ListWebExperiencesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWebExperiencesResponse {
        try await self.client.execute(
            operation: "ListWebExperiences", 
            path: "/applications/{applicationId}/experiences", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists one or more Amazon Q Business Web Experiences.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application linked to the listed web experiences.
    ///   - maxResults: The maximum number of Amazon Q Business Web Experiences to return.
    ///   - nextToken: If the maxResults response was incomplete because there is more data to retrieve, Amazon Q Business returns a pagination token in the response. You can use this pagination token to retrieve the next set of Amazon Q Business conversations.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWebExperiences(
        applicationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWebExperiencesResponse {
        let input = ListWebExperiencesRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listWebExperiences(input, logger: logger)
    }

    /// Enables your end user to provide feedback on their Amazon Q Business generated chat responses.
    @Sendable
    @inlinable
    public func putFeedback(_ input: PutFeedbackRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "PutFeedback", 
            path: "/applications/{applicationId}/conversations/{conversationId}/messages/{messageId}/feedback", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables your end user to provide feedback on their Amazon Q Business generated chat responses.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application associated with the feedback.
    ///   - conversationId: The identifier of the conversation the feedback is attached to.
    ///   - messageCopiedAt: The timestamp for when the feedback was recorded.
    ///   - messageId: The identifier of the chat message that the feedback was given for.
    ///   - messageUsefulness: The feedback usefulness value given by the user to the chat message.
    ///   - userId: The identifier of the user giving the feedback.
    ///   - logger: Logger use during operation
    @inlinable
    public func putFeedback(
        applicationId: String,
        conversationId: String,
        messageCopiedAt: Date? = nil,
        messageId: String,
        messageUsefulness: MessageUsefulnessFeedback? = nil,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = PutFeedbackRequest(
            applicationId: applicationId, 
            conversationId: conversationId, 
            messageCopiedAt: messageCopiedAt, 
            messageId: messageId, 
            messageUsefulness: messageUsefulness, 
            userId: userId
        )
        return try await self.putFeedback(input, logger: logger)
    }

    /// Create, or updates, a mapping of users—who have access to a document—to groups. You can also map sub groups to groups. For example, the group "Company Intellectual Property Teams" includes sub groups "Research" and "Engineering". These sub groups include their own list of users or people who work in these teams. Only users who work in research and engineering, and therefore belong in the intellectual property group, can see top-secret company documents in their Amazon Q Business chat results. There are two options for creating groups, either passing group members inline or using an S3 file via the S3PathForGroupMembers field. For inline groups, there is a limit of 1000 members per group and for provided S3 files there is a limit of 100 thousand members. When creating a group using an S3 file, you provide both an S3 file and a RoleArn for Amazon Q Buisness to access the file.
    @Sendable
    @inlinable
    public func putGroup(_ input: PutGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutGroupResponse {
        try await self.client.execute(
            operation: "PutGroup", 
            path: "/applications/{applicationId}/indices/{indexId}/groups", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Create, or updates, a mapping of users—who have access to a document—to groups. You can also map sub groups to groups. For example, the group "Company Intellectual Property Teams" includes sub groups "Research" and "Engineering". These sub groups include their own list of users or people who work in these teams. Only users who work in research and engineering, and therefore belong in the intellectual property group, can see top-secret company documents in their Amazon Q Business chat results. There are two options for creating groups, either passing group members inline or using an S3 file via the S3PathForGroupMembers field. For inline groups, there is a limit of 1000 members per group and for provided S3 files there is a limit of 100 thousand members. When creating a group using an S3 file, you provide both an S3 file and a RoleArn for Amazon Q Buisness to access the file.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application in which the user and group mapping belongs.
    ///   - dataSourceId: The identifier of the data source for which you want to map users to their groups. This is useful if a group is tied to multiple data sources, but you only want the group to access documents of a certain data source. For example, the groups "Research", "Engineering", and "Sales and Marketing" are all tied to the company's documents stored in the data sources Confluence and Salesforce. However, "Sales and Marketing" team only needs access to customer-related documents stored in Salesforce.
    ///   - groupMembers: 
    ///   - groupName: The list that contains your users or sub groups that belong the same group. For example, the group "Company" includes the user "CEO" and the sub groups "Research", "Engineering", and "Sales and Marketing".
    ///   - indexId: The identifier of the index in which you want to map users to their groups.
    ///   - roleArn: The Amazon Resource Name (ARN) of an IAM role that has access to the S3 file that contains your list of users that belong to a group.
    ///   - type: The type of the group.
    ///   - logger: Logger use during operation
    @inlinable
    public func putGroup(
        applicationId: String,
        dataSourceId: String? = nil,
        groupMembers: GroupMembers,
        groupName: String,
        indexId: String,
        roleArn: String? = nil,
        type: MembershipType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutGroupResponse {
        let input = PutGroupRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            groupMembers: groupMembers, 
            groupName: groupName, 
            indexId: indexId, 
            roleArn: roleArn, 
            type: type
        )
        return try await self.putGroup(input, logger: logger)
    }

    /// Searches for relevant content in a Amazon Q Business application based on a query. This operation takes a search query text, the Amazon Q Business application identifier, and optional filters (such as content source and maximum results) as input. It returns a list of relevant content items, where each item includes the content text, the unique document identifier, the document title, the document URI, any relevant document attributes, and score attributes indicating the confidence level of the relevance.
    @Sendable
    @inlinable
    public func searchRelevantContent(_ input: SearchRelevantContentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchRelevantContentResponse {
        try await self.client.execute(
            operation: "SearchRelevantContent", 
            path: "/applications/{applicationId}/relevant-content", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for relevant content in a Amazon Q Business application based on a query. This operation takes a search query text, the Amazon Q Business application identifier, and optional filters (such as content source and maximum results) as input. It returns a list of relevant content items, where each item includes the content text, the unique document identifier, the document title, the document URI, any relevant document attributes, and score attributes indicating the confidence level of the relevance.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application to search.
    ///   - attributeFilter: 
    ///   - contentSource: The source of content to search in.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next set of results. (You received this token from a previous call.)
    ///   - queryText: The text to search for.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchRelevantContent(
        applicationId: String,
        attributeFilter: AttributeFilter? = nil,
        contentSource: ContentSource,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        queryText: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchRelevantContentResponse {
        let input = SearchRelevantContentRequest(
            applicationId: applicationId, 
            attributeFilter: attributeFilter, 
            contentSource: contentSource, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            queryText: queryText
        )
        return try await self.searchRelevantContent(input, logger: logger)
    }

    /// Starts a data source connector synchronization job. If a synchronization job is already in progress, Amazon Q Business returns a ConflictException.
    @Sendable
    @inlinable
    public func startDataSourceSyncJob(_ input: StartDataSourceSyncJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartDataSourceSyncJobResponse {
        try await self.client.execute(
            operation: "StartDataSourceSyncJob", 
            path: "/applications/{applicationId}/indices/{indexId}/datasources/{dataSourceId}/startsync", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts a data source connector synchronization job. If a synchronization job is already in progress, Amazon Q Business returns a ConflictException.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of Amazon Q Business application the data source is connected to.
    ///   - dataSourceId:  The identifier of the data source connector.
    ///   - indexId: The identifier of the index used with the data source connector.
    ///   - logger: Logger use during operation
    @inlinable
    public func startDataSourceSyncJob(
        applicationId: String,
        dataSourceId: String,
        indexId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartDataSourceSyncJobResponse {
        let input = StartDataSourceSyncJobRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            indexId: indexId
        )
        return try await self.startDataSourceSyncJob(input, logger: logger)
    }

    /// Stops an Amazon Q Business data source connector synchronization job already in progress.
    @Sendable
    @inlinable
    public func stopDataSourceSyncJob(_ input: StopDataSourceSyncJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StopDataSourceSyncJobResponse {
        try await self.client.execute(
            operation: "StopDataSourceSyncJob", 
            path: "/applications/{applicationId}/indices/{indexId}/datasources/{dataSourceId}/stopsync", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Stops an Amazon Q Business data source connector synchronization job already in progress.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application that the data source is connected to.
    ///   - dataSourceId:  The identifier of the data source connector.
    ///   - indexId: The identifier of the index used with the Amazon Q Business data source connector.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopDataSourceSyncJob(
        applicationId: String,
        dataSourceId: String,
        indexId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopDataSourceSyncJobResponse {
        let input = StopDataSourceSyncJobRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            indexId: indexId
        )
        return try await self.stopDataSourceSyncJob(input, logger: logger)
    }

    /// Adds the specified tag to the specified Amazon Q Business application or data source resource. If the tag already exists, the existing value is replaced with the new value.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/v1/tags/{resourceARN}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds the specified tag to the specified Amazon Q Business application or data source resource. If the tag already exists, the existing value is replaced with the new value.
    ///
    /// Parameters:
    ///   - resourceARN: The Amazon Resource Name (ARN) of the Amazon Q Business application or data source to tag.
    ///   - tags: A list of tag keys to add to the Amazon Q Business application or data source. If a tag already exists, the existing value is replaced with the new value.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceARN: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceARN: resourceARN, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes a tag from an Amazon Q Business application or a data source.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/v1/tags/{resourceARN}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a tag from an Amazon Q Business application or a data source.
    ///
    /// Parameters:
    ///   - resourceARN: The Amazon Resource Name (ARN) of the Amazon Q Business application, or data source to remove the tag from.
    ///   - tagKeys: A list of tag keys to remove from the Amazon Q Business application or data source. If a tag key does not exist on the resource, it is ignored.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceARN: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceARN: resourceARN, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates an existing Amazon Q Business application.  Amazon Q Business applications may securely transmit data for processing across Amazon Web Services Regions within your geography. For more information, see Cross region inference in Amazon Q Business.   An Amazon Q Apps service-linked role will be created if it's absent in the Amazon Web Services account when QAppsConfiguration is enabled in the request. For more information, see Using service-linked roles for Q Apps.
    @Sendable
    @inlinable
    public func updateApplication(_ input: UpdateApplicationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateApplicationResponse {
        try await self.client.execute(
            operation: "UpdateApplication", 
            path: "/applications/{applicationId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing Amazon Q Business application.  Amazon Q Business applications may securely transmit data for processing across Amazon Web Services Regions within your geography. For more information, see Cross region inference in Amazon Q Business.   An Amazon Q Apps service-linked role will be created if it's absent in the Amazon Web Services account when QAppsConfiguration is enabled in the request. For more information, see Using service-linked roles for Q Apps.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application.
    ///   - attachmentsConfiguration: An option to allow end users to upload files directly during chat.
    ///   - autoSubscriptionConfiguration: An option to enable updating the default subscription type assigned to an Amazon Q Business application using IAM identity federation for user management.
    ///   - description: A description for the Amazon Q Business application.
    ///   - displayName: A name for the Amazon Q Business application.
    ///   - identityCenterInstanceArn:  The Amazon Resource Name (ARN) of the IAM Identity Center instance you are either creating for—or connecting to—your Amazon Q Business application.
    ///   - personalizationConfiguration: Configuration information about chat response personalization. For more information, see Personalizing chat responses.
    ///   - qAppsConfiguration: An option to allow end users to create and use Amazon Q Apps in the web experience.
    ///   - roleArn: An Amazon Web Services Identity and Access Management (IAM) role that gives Amazon Q Business permission to access Amazon CloudWatch logs and metrics.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateApplication(
        applicationId: String,
        attachmentsConfiguration: AttachmentsConfiguration? = nil,
        autoSubscriptionConfiguration: AutoSubscriptionConfiguration? = nil,
        description: String? = nil,
        displayName: String? = nil,
        identityCenterInstanceArn: String? = nil,
        personalizationConfiguration: PersonalizationConfiguration? = nil,
        qAppsConfiguration: QAppsConfiguration? = nil,
        roleArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateApplicationResponse {
        let input = UpdateApplicationRequest(
            applicationId: applicationId, 
            attachmentsConfiguration: attachmentsConfiguration, 
            autoSubscriptionConfiguration: autoSubscriptionConfiguration, 
            description: description, 
            displayName: displayName, 
            identityCenterInstanceArn: identityCenterInstanceArn, 
            personalizationConfiguration: personalizationConfiguration, 
            qAppsConfiguration: qAppsConfiguration, 
            roleArn: roleArn
        )
        return try await self.updateApplication(input, logger: logger)
    }

    /// Updates a set of chat controls configured for an existing Amazon Q Business application.
    @Sendable
    @inlinable
    public func updateChatControlsConfiguration(_ input: UpdateChatControlsConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateChatControlsConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateChatControlsConfiguration", 
            path: "/applications/{applicationId}/chatcontrols", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a set of chat controls configured for an existing Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application for which the chat controls are configured.
    ///   - blockedPhrasesConfigurationUpdate: The phrases blocked from chat by your chat control configuration.
    ///   - clientToken: A token that you provide to identify the request to update a Amazon Q Business application chat configuration.
    ///   - creatorModeConfiguration: The configuration details for CREATOR_MODE.
    ///   - hallucinationReductionConfiguration:  The hallucination reduction settings for your application.
    ///   - orchestrationConfiguration:  The chat response orchestration settings for your application.
    ///   - responseScope: The response scope configured for your application. This determines whether your application uses its retrieval augmented generation (RAG) system to generate answers only from your enterprise data, or also uses the large language models (LLM) knowledge to respons to end user questions in chat.
    ///   - topicConfigurationsToCreateOrUpdate: The configured topic specific chat controls you want to update.
    ///   - topicConfigurationsToDelete: The configured topic specific chat controls you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateChatControlsConfiguration(
        applicationId: String,
        blockedPhrasesConfigurationUpdate: BlockedPhrasesConfigurationUpdate? = nil,
        clientToken: String? = UpdateChatControlsConfigurationRequest.idempotencyToken(),
        creatorModeConfiguration: CreatorModeConfiguration? = nil,
        hallucinationReductionConfiguration: HallucinationReductionConfiguration? = nil,
        orchestrationConfiguration: OrchestrationConfiguration? = nil,
        responseScope: ResponseScope? = nil,
        topicConfigurationsToCreateOrUpdate: [TopicConfiguration]? = nil,
        topicConfigurationsToDelete: [TopicConfiguration]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateChatControlsConfigurationResponse {
        let input = UpdateChatControlsConfigurationRequest(
            applicationId: applicationId, 
            blockedPhrasesConfigurationUpdate: blockedPhrasesConfigurationUpdate, 
            clientToken: clientToken, 
            creatorModeConfiguration: creatorModeConfiguration, 
            hallucinationReductionConfiguration: hallucinationReductionConfiguration, 
            orchestrationConfiguration: orchestrationConfiguration, 
            responseScope: responseScope, 
            topicConfigurationsToCreateOrUpdate: topicConfigurationsToCreateOrUpdate, 
            topicConfigurationsToDelete: topicConfigurationsToDelete
        )
        return try await self.updateChatControlsConfiguration(input, logger: logger)
    }

    /// Updates an existing chat response configuration in an Amazon Q Business application. This operation allows administrators to modify configuration settings, display name, and response parameters to refine how the system generates responses.
    @Sendable
    @inlinable
    public func updateChatResponseConfiguration(_ input: UpdateChatResponseConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateChatResponseConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateChatResponseConfiguration", 
            path: "/applications/{applicationId}/chatresponseconfigurations/{chatResponseConfigurationId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing chat response configuration in an Amazon Q Business application. This operation allows administrators to modify configuration settings, display name, and response parameters to refine how the system generates responses.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application containing the chat response configuration to update.
    ///   - chatResponseConfigurationId: The unique identifier of the chat response configuration to update within the specified application.
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request. This helps prevent the same update from being processed multiple times if retries occur.
    ///   - displayName: The new human-readable name to assign to the chat response configuration, making it easier to identify among multiple configurations.
    ///   - responseConfigurations: The updated collection of response configuration settings that define how Amazon Q Business generates and formats responses to user queries.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateChatResponseConfiguration(
        applicationId: String,
        chatResponseConfigurationId: String,
        clientToken: String? = UpdateChatResponseConfigurationRequest.idempotencyToken(),
        displayName: String? = nil,
        responseConfigurations: [ResponseConfigurationType: ResponseConfiguration],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateChatResponseConfigurationResponse {
        let input = UpdateChatResponseConfigurationRequest(
            applicationId: applicationId, 
            chatResponseConfigurationId: chatResponseConfigurationId, 
            clientToken: clientToken, 
            displayName: displayName, 
            responseConfigurations: responseConfigurations
        )
        return try await self.updateChatResponseConfiguration(input, logger: logger)
    }

    /// Updates an existing data accessor. This operation allows modifying the action configurations (the allowed actions and associated filters) and the display name of the data accessor. It does not allow changing the IAM role associated with the data accessor or other core properties of the data accessor.
    @Sendable
    @inlinable
    public func updateDataAccessor(_ input: UpdateDataAccessorRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDataAccessorResponse {
        try await self.client.execute(
            operation: "UpdateDataAccessor", 
            path: "/applications/{applicationId}/dataaccessors/{dataAccessorId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing data accessor. This operation allows modifying the action configurations (the allowed actions and associated filters) and the display name of the data accessor. It does not allow changing the IAM role associated with the data accessor or other core properties of the data accessor.
    ///
    /// Parameters:
    ///   - actionConfigurations: The updated list of action configurations specifying the allowed actions and any associated filters.
    ///   - applicationId: The unique identifier of the Amazon Q Business application.
    ///   - authenticationDetail: The updated authentication configuration details for the data accessor. This specifies how the ISV will authenticate when accessing data through this data accessor.
    ///   - dataAccessorId: The unique identifier of the data accessor to update.
    ///   - displayName: The updated friendly name for the data accessor.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDataAccessor(
        actionConfigurations: [ActionConfiguration],
        applicationId: String,
        authenticationDetail: DataAccessorAuthenticationDetail? = nil,
        dataAccessorId: String,
        displayName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDataAccessorResponse {
        let input = UpdateDataAccessorRequest(
            actionConfigurations: actionConfigurations, 
            applicationId: applicationId, 
            authenticationDetail: authenticationDetail, 
            dataAccessorId: dataAccessorId, 
            displayName: displayName
        )
        return try await self.updateDataAccessor(input, logger: logger)
    }

    /// Updates an existing Amazon Q Business data source connector.
    @Sendable
    @inlinable
    public func updateDataSource(_ input: UpdateDataSourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDataSourceResponse {
        try await self.client.execute(
            operation: "UpdateDataSource", 
            path: "/applications/{applicationId}/indices/{indexId}/datasources/{dataSourceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing Amazon Q Business data source connector.
    ///
    /// Parameters:
    ///   - applicationId:  The identifier of the Amazon Q Business application the data source is attached to.
    ///   - configuration: 
    ///   - dataSourceId: The identifier of the data source connector.
    ///   - description: The description of the data source connector.
    ///   - displayName: A name of the data source connector.
    ///   - documentEnrichmentConfiguration: 
    ///   - indexId: The identifier of the index attached to the data source connector.
    ///   - mediaExtractionConfiguration: The configuration for extracting information from media in documents for your data source.
    ///   - roleArn: The Amazon Resource Name (ARN) of an IAM role with permission to access the data source and required resources.
    ///   - syncSchedule: The chosen update frequency for your data source.
    ///   - vpcConfiguration: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDataSource(
        applicationId: String,
        configuration: AWSDocument? = nil,
        dataSourceId: String,
        description: String? = nil,
        displayName: String? = nil,
        documentEnrichmentConfiguration: DocumentEnrichmentConfiguration? = nil,
        indexId: String,
        mediaExtractionConfiguration: MediaExtractionConfiguration? = nil,
        roleArn: String? = nil,
        syncSchedule: String? = nil,
        vpcConfiguration: DataSourceVpcConfiguration? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDataSourceResponse {
        let input = UpdateDataSourceRequest(
            applicationId: applicationId, 
            configuration: configuration, 
            dataSourceId: dataSourceId, 
            description: description, 
            displayName: displayName, 
            documentEnrichmentConfiguration: documentEnrichmentConfiguration, 
            indexId: indexId, 
            mediaExtractionConfiguration: mediaExtractionConfiguration, 
            roleArn: roleArn, 
            syncSchedule: syncSchedule, 
            vpcConfiguration: vpcConfiguration
        )
        return try await self.updateDataSource(input, logger: logger)
    }

    /// Updates an Amazon Q Business index.
    @Sendable
    @inlinable
    public func updateIndex(_ input: UpdateIndexRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateIndexResponse {
        try await self.client.execute(
            operation: "UpdateIndex", 
            path: "/applications/{applicationId}/indices/{indexId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an Amazon Q Business index.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application connected to the index.
    ///   - capacityConfiguration: The storage capacity units you want to provision for your Amazon Q Business index. You can add and remove capacity to fit your usage needs.
    ///   - description: The description of the Amazon Q Business index.
    ///   - displayName: The name of the Amazon Q Business index.
    ///   - documentAttributeConfigurations: Configuration information for document metadata or fields. Document metadata are fields or attributes associated with your documents. For example, the company department name associated with each document. For more information, see Understanding document attributes.
    ///   - indexId: The identifier of the Amazon Q Business index.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateIndex(
        applicationId: String,
        capacityConfiguration: IndexCapacityConfiguration? = nil,
        description: String? = nil,
        displayName: String? = nil,
        documentAttributeConfigurations: [DocumentAttributeConfiguration]? = nil,
        indexId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateIndexResponse {
        let input = UpdateIndexRequest(
            applicationId: applicationId, 
            capacityConfiguration: capacityConfiguration, 
            description: description, 
            displayName: displayName, 
            documentAttributeConfigurations: documentAttributeConfigurations, 
            indexId: indexId
        )
        return try await self.updateIndex(input, logger: logger)
    }

    /// Updates an Amazon Q Business plugin.
    @Sendable
    @inlinable
    public func updatePlugin(_ input: UpdatePluginRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePluginResponse {
        try await self.client.execute(
            operation: "UpdatePlugin", 
            path: "/applications/{applicationId}/plugins/{pluginId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an Amazon Q Business plugin.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application the plugin is attached to.
    ///   - authConfiguration: The authentication configuration the plugin is using.
    ///   - customPluginConfiguration: The configuration for a custom plugin.
    ///   - displayName: The name of the plugin.
    ///   - pluginId: The identifier of the plugin.
    ///   - serverUrl: The source URL used for plugin configuration.
    ///   - state: The status of the plugin.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePlugin(
        applicationId: String,
        authConfiguration: PluginAuthConfiguration? = nil,
        customPluginConfiguration: CustomPluginConfiguration? = nil,
        displayName: String? = nil,
        pluginId: String,
        serverUrl: String? = nil,
        state: PluginState? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePluginResponse {
        let input = UpdatePluginRequest(
            applicationId: applicationId, 
            authConfiguration: authConfiguration, 
            customPluginConfiguration: customPluginConfiguration, 
            displayName: displayName, 
            pluginId: pluginId, 
            serverUrl: serverUrl, 
            state: state
        )
        return try await self.updatePlugin(input, logger: logger)
    }

    /// Updates the retriever used for your Amazon Q Business application.
    @Sendable
    @inlinable
    public func updateRetriever(_ input: UpdateRetrieverRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateRetrieverResponse {
        try await self.client.execute(
            operation: "UpdateRetriever", 
            path: "/applications/{applicationId}/retrievers/{retrieverId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the retriever used for your Amazon Q Business application.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of your Amazon Q Business application.
    ///   - configuration: 
    ///   - displayName: The name of your retriever.
    ///   - retrieverId: The identifier of your retriever.
    ///   - roleArn: The Amazon Resource Name (ARN) of an IAM role with permission to access the retriever and required resources.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRetriever(
        applicationId: String,
        configuration: RetrieverConfiguration? = nil,
        displayName: String? = nil,
        retrieverId: String,
        roleArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateRetrieverResponse {
        let input = UpdateRetrieverRequest(
            applicationId: applicationId, 
            configuration: configuration, 
            displayName: displayName, 
            retrieverId: retrieverId, 
            roleArn: roleArn
        )
        return try await self.updateRetriever(input, logger: logger)
    }

    /// Updates the pricing tier for an Amazon Q Business subscription. Upgrades are instant. Downgrades apply at the start of the next month. Subscription tier determines feature access for the user. For more information on subscriptions and pricing tiers, see Amazon Q Business pricing.
    @Sendable
    @inlinable
    public func updateSubscription(_ input: UpdateSubscriptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSubscriptionResponse {
        try await self.client.execute(
            operation: "UpdateSubscription", 
            path: "/applications/{applicationId}/subscriptions/{subscriptionId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the pricing tier for an Amazon Q Business subscription. Upgrades are instant. Downgrades apply at the start of the next month. Subscription tier determines feature access for the user. For more information on subscriptions and pricing tiers, see Amazon Q Business pricing.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application where the subscription update should take effect.
    ///   - subscriptionId: The identifier of the Amazon Q Business subscription to be updated.
    ///   - type: The type of the Amazon Q Business subscription to be updated.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSubscription(
        applicationId: String,
        subscriptionId: String,
        type: SubscriptionType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSubscriptionResponse {
        let input = UpdateSubscriptionRequest(
            applicationId: applicationId, 
            subscriptionId: subscriptionId, 
            type: type
        )
        return try await self.updateSubscription(input, logger: logger)
    }

    /// Updates a information associated with a user id.
    @Sendable
    @inlinable
    public func updateUser(_ input: UpdateUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateUserResponse {
        try await self.client.execute(
            operation: "UpdateUser", 
            path: "/applications/{applicationId}/users/{userId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a information associated with a user id.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the application the user is attached to.
    ///   - userAliasesToDelete: The user aliases attached to the user id that are to be deleted.
    ///   - userAliasesToUpdate: The user aliases attached to the user id that are to be updated.
    ///   - userId: The email id attached to the user.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUser(
        applicationId: String,
        userAliasesToDelete: [UserAlias]? = nil,
        userAliasesToUpdate: [UserAlias]? = nil,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateUserResponse {
        let input = UpdateUserRequest(
            applicationId: applicationId, 
            userAliasesToDelete: userAliasesToDelete, 
            userAliasesToUpdate: userAliasesToUpdate, 
            userId: userId
        )
        return try await self.updateUser(input, logger: logger)
    }

    /// Updates an Amazon Q Business web experience.
    @Sendable
    @inlinable
    public func updateWebExperience(_ input: UpdateWebExperienceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateWebExperienceResponse {
        try await self.client.execute(
            operation: "UpdateWebExperience", 
            path: "/applications/{applicationId}/experiences/{webExperienceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an Amazon Q Business web experience.
    ///
    /// Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application attached to the web experience.
    ///   - browserExtensionConfiguration: The browser extension configuration for an Amazon Q Business web experience.   For Amazon Q Business application using external OIDC-compliant identity providers (IdPs). The IdP administrator must add the browser extension sign-in redirect URLs to the IdP application. For more information, see Configure external OIDC identity provider for your browser extensions..
    ///   - customizationConfiguration: Updates the custom logo, favicon, font, and color used in the Amazon Q web experience.
    ///   - identityProviderConfiguration: Information about the identity provider (IdP) used to authenticate end users of an Amazon Q Business web experience.
    ///   - origins: Updates the website domain origins that are allowed to embed the Amazon Q Business web experience. The domain origin refers to the base URL for accessing a website including the protocol (http/https), the domain name, and the port number (if specified).    Any values except null submitted as part of this update will replace all previous values.   You must only submit a base URL and not a full path. For example, https://docs.aws.amazon.com.
    ///   - roleArn: The Amazon Resource Name (ARN) of the role with permission to access the Amazon Q Business web experience and required resources.
    ///   - samplePromptsControlMode: Determines whether sample prompts are enabled in the web experience for an end user.
    ///   - subtitle: The subtitle of the Amazon Q Business web experience.
    ///   - title: The title of the Amazon Q Business web experience.
    ///   - webExperienceId: The identifier of the Amazon Q Business web experience.
    ///   - welcomeMessage: A customized welcome message for an end user in an Amazon Q Business web experience.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateWebExperience(
        applicationId: String,
        browserExtensionConfiguration: BrowserExtensionConfiguration? = nil,
        customizationConfiguration: CustomizationConfiguration? = nil,
        identityProviderConfiguration: IdentityProviderConfiguration? = nil,
        origins: [String]? = nil,
        roleArn: String? = nil,
        samplePromptsControlMode: WebExperienceSamplePromptsControlMode? = nil,
        subtitle: String? = nil,
        title: String? = nil,
        webExperienceId: String,
        welcomeMessage: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateWebExperienceResponse {
        let input = UpdateWebExperienceRequest(
            applicationId: applicationId, 
            browserExtensionConfiguration: browserExtensionConfiguration, 
            customizationConfiguration: customizationConfiguration, 
            identityProviderConfiguration: identityProviderConfiguration, 
            origins: origins, 
            roleArn: roleArn, 
            samplePromptsControlMode: samplePromptsControlMode, 
            subtitle: subtitle, 
            title: title, 
            webExperienceId: webExperienceId, 
            welcomeMessage: welcomeMessage
        )
        return try await self.updateWebExperience(input, logger: logger)
    }
}

extension QBusiness {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: QBusiness, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension QBusiness {
    /// Return PaginatorSequence for operation ``getChatControlsConfiguration(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getChatControlsConfigurationPaginator(
        _ input: GetChatControlsConfigurationRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetChatControlsConfigurationRequest, GetChatControlsConfigurationResponse> {
        return .init(
            input: input,
            command: self.getChatControlsConfiguration,
            inputKey: \GetChatControlsConfigurationRequest.nextToken,
            outputKey: \GetChatControlsConfigurationResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getChatControlsConfiguration(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the application for which the chat controls are configured.
    ///   - maxResults: The maximum number of configured chat controls to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func getChatControlsConfigurationPaginator(
        applicationId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetChatControlsConfigurationRequest, GetChatControlsConfigurationResponse> {
        let input = GetChatControlsConfigurationRequest(
            applicationId: applicationId, 
            maxResults: maxResults
        )
        return self.getChatControlsConfigurationPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listApplications(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listApplicationsPaginator(
        _ input: ListApplicationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListApplicationsRequest, ListApplicationsResponse> {
        return .init(
            input: input,
            command: self.listApplications,
            inputKey: \ListApplicationsRequest.nextToken,
            outputKey: \ListApplicationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listApplications(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of Amazon Q Business applications to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listApplicationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListApplicationsRequest, ListApplicationsResponse> {
        let input = ListApplicationsRequest(
            maxResults: maxResults
        )
        return self.listApplicationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAttachments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAttachmentsPaginator(
        _ input: ListAttachmentsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAttachmentsRequest, ListAttachmentsResponse> {
        return .init(
            input: input,
            command: self.listAttachments,
            inputKey: \ListAttachmentsRequest.nextToken,
            outputKey: \ListAttachmentsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAttachments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The unique identifier for the Amazon Q Business application.
    ///   - conversationId: The unique identifier of the Amazon Q Business web experience conversation.
    ///   - maxResults: The maximum number of attachements to return.
    ///   - userId: The unique identifier of the user involved in the Amazon Q Business web experience conversation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAttachmentsPaginator(
        applicationId: String,
        conversationId: String? = nil,
        maxResults: Int? = nil,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAttachmentsRequest, ListAttachmentsResponse> {
        let input = ListAttachmentsRequest(
            applicationId: applicationId, 
            conversationId: conversationId, 
            maxResults: maxResults, 
            userId: userId
        )
        return self.listAttachmentsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listChatResponseConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listChatResponseConfigurationsPaginator(
        _ input: ListChatResponseConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListChatResponseConfigurationsRequest, ListChatResponseConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listChatResponseConfigurations,
            inputKey: \ListChatResponseConfigurationsRequest.nextToken,
            outputKey: \ListChatResponseConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listChatResponseConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application for which to list available chat response configurations.
    ///   - maxResults: The maximum number of chat response configurations to return in a single response. This parameter helps control pagination of results when many configurations exist.
    ///   - logger: Logger used for logging
    @inlinable
    public func listChatResponseConfigurationsPaginator(
        applicationId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListChatResponseConfigurationsRequest, ListChatResponseConfigurationsResponse> {
        let input = ListChatResponseConfigurationsRequest(
            applicationId: applicationId, 
            maxResults: maxResults
        )
        return self.listChatResponseConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listConversations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listConversationsPaginator(
        _ input: ListConversationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListConversationsRequest, ListConversationsResponse> {
        return .init(
            input: input,
            command: self.listConversations,
            inputKey: \ListConversationsRequest.nextToken,
            outputKey: \ListConversationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listConversations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application.
    ///   - maxResults: The maximum number of Amazon Q Business conversations to return.
    ///   - userId: The identifier of the user involved in the Amazon Q Business web experience conversation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listConversationsPaginator(
        applicationId: String,
        maxResults: Int? = nil,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListConversationsRequest, ListConversationsResponse> {
        let input = ListConversationsRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            userId: userId
        )
        return self.listConversationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDataAccessors(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataAccessorsPaginator(
        _ input: ListDataAccessorsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDataAccessorsRequest, ListDataAccessorsResponse> {
        return .init(
            input: input,
            command: self.listDataAccessors,
            inputKey: \ListDataAccessorsRequest.nextToken,
            outputKey: \ListDataAccessorsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDataAccessors(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application.
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataAccessorsPaginator(
        applicationId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDataAccessorsRequest, ListDataAccessorsResponse> {
        let input = ListDataAccessorsRequest(
            applicationId: applicationId, 
            maxResults: maxResults
        )
        return self.listDataAccessorsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDataSourceSyncJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataSourceSyncJobsPaginator(
        _ input: ListDataSourceSyncJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDataSourceSyncJobsRequest, ListDataSourceSyncJobsResponse> {
        return .init(
            input: input,
            command: self.listDataSourceSyncJobs,
            inputKey: \ListDataSourceSyncJobsRequest.nextToken,
            outputKey: \ListDataSourceSyncJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDataSourceSyncJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application connected to the data source.
    ///   - dataSourceId:  The identifier of the data source connector.
    ///   - endTime:  The end time of the data source connector sync.
    ///   - indexId: The identifier of the index used with the Amazon Q Business data source connector.
    ///   - maxResults: The maximum number of synchronization jobs to return in the response.
    ///   - startTime:  The start time of the data source connector sync.
    ///   - statusFilter: Only returns synchronization jobs with the Status field equal to the specified status.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataSourceSyncJobsPaginator(
        applicationId: String,
        dataSourceId: String,
        endTime: Date? = nil,
        indexId: String,
        maxResults: Int? = nil,
        startTime: Date? = nil,
        statusFilter: DataSourceSyncJobStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDataSourceSyncJobsRequest, ListDataSourceSyncJobsResponse> {
        let input = ListDataSourceSyncJobsRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            endTime: endTime, 
            indexId: indexId, 
            maxResults: maxResults, 
            startTime: startTime, 
            statusFilter: statusFilter
        )
        return self.listDataSourceSyncJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDataSources(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataSourcesPaginator(
        _ input: ListDataSourcesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDataSourcesRequest, ListDataSourcesResponse> {
        return .init(
            input: input,
            command: self.listDataSources,
            inputKey: \ListDataSourcesRequest.nextToken,
            outputKey: \ListDataSourcesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDataSources(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application linked to the data source connectors.
    ///   - indexId: The identifier of the index used with one or more data source connectors.
    ///   - maxResults: The maximum number of data source connectors to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataSourcesPaginator(
        applicationId: String,
        indexId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDataSourcesRequest, ListDataSourcesResponse> {
        let input = ListDataSourcesRequest(
            applicationId: applicationId, 
            indexId: indexId, 
            maxResults: maxResults
        )
        return self.listDataSourcesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDocuments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDocumentsPaginator(
        _ input: ListDocumentsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDocumentsRequest, ListDocumentsResponse> {
        return .init(
            input: input,
            command: self.listDocuments,
            inputKey: \ListDocumentsRequest.nextToken,
            outputKey: \ListDocumentsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDocuments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the application id the documents are attached to.
    ///   - dataSourceIds: The identifier of the data sources the documents are attached to.
    ///   - indexId: The identifier of the index the documents are attached to.
    ///   - maxResults: The maximum number of documents to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDocumentsPaginator(
        applicationId: String,
        dataSourceIds: [String]? = nil,
        indexId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDocumentsRequest, ListDocumentsResponse> {
        let input = ListDocumentsRequest(
            applicationId: applicationId, 
            dataSourceIds: dataSourceIds, 
            indexId: indexId, 
            maxResults: maxResults
        )
        return self.listDocumentsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listGroupsPaginator(
        _ input: ListGroupsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListGroupsRequest, ListGroupsResponse> {
        return .init(
            input: input,
            command: self.listGroups,
            inputKey: \ListGroupsRequest.nextToken,
            outputKey: \ListGroupsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the application for getting a list of groups mapped to users.
    ///   - dataSourceId: The identifier of the data source for getting a list of groups mapped to users.
    ///   - indexId: The identifier of the index for getting a list of groups mapped to users.
    ///   - maxResults: The maximum number of returned groups that are mapped to users.
    ///   - updatedEarlierThan: The timestamp identifier used for the latest PUT or DELETE action for mapping users to their groups.
    ///   - logger: Logger used for logging
    @inlinable
    public func listGroupsPaginator(
        applicationId: String,
        dataSourceId: String? = nil,
        indexId: String,
        maxResults: Int? = nil,
        updatedEarlierThan: Date,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListGroupsRequest, ListGroupsResponse> {
        let input = ListGroupsRequest(
            applicationId: applicationId, 
            dataSourceId: dataSourceId, 
            indexId: indexId, 
            maxResults: maxResults, 
            updatedEarlierThan: updatedEarlierThan
        )
        return self.listGroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listIndices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listIndicesPaginator(
        _ input: ListIndicesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListIndicesRequest, ListIndicesResponse> {
        return .init(
            input: input,
            command: self.listIndices,
            inputKey: \ListIndicesRequest.nextToken,
            outputKey: \ListIndicesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listIndices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application connected to the index.
    ///   - maxResults: The maximum number of indices to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listIndicesPaginator(
        applicationId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListIndicesRequest, ListIndicesResponse> {
        let input = ListIndicesRequest(
            applicationId: applicationId, 
            maxResults: maxResults
        )
        return self.listIndicesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMessages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMessagesPaginator(
        _ input: ListMessagesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMessagesRequest, ListMessagesResponse> {
        return .init(
            input: input,
            command: self.listMessages,
            inputKey: \ListMessagesRequest.nextToken,
            outputKey: \ListMessagesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMessages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier for the Amazon Q Business application.
    ///   - conversationId: The identifier of the Amazon Q Business web experience conversation.
    ///   - maxResults: The maximum number of messages to return.
    ///   - userId: The identifier of the user involved in the Amazon Q Business web experience conversation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMessagesPaginator(
        applicationId: String,
        conversationId: String,
        maxResults: Int? = nil,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMessagesRequest, ListMessagesResponse> {
        let input = ListMessagesRequest(
            applicationId: applicationId, 
            conversationId: conversationId, 
            maxResults: maxResults, 
            userId: userId
        )
        return self.listMessagesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPluginActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPluginActionsPaginator(
        _ input: ListPluginActionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPluginActionsRequest, ListPluginActionsResponse> {
        return .init(
            input: input,
            command: self.listPluginActions,
            inputKey: \ListPluginActionsRequest.nextToken,
            outputKey: \ListPluginActionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPluginActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application the plugin is attached to.
    ///   - maxResults: The maximum number of plugin actions to return.
    ///   - pluginId: The identifier of the Amazon Q Business plugin.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPluginActionsPaginator(
        applicationId: String,
        maxResults: Int? = nil,
        pluginId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPluginActionsRequest, ListPluginActionsResponse> {
        let input = ListPluginActionsRequest(
            applicationId: applicationId, 
            maxResults: maxResults, 
            pluginId: pluginId
        )
        return self.listPluginActionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPluginTypeActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPluginTypeActionsPaginator(
        _ input: ListPluginTypeActionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPluginTypeActionsRequest, ListPluginTypeActionsResponse> {
        return .init(
            input: input,
            command: self.listPluginTypeActions,
            inputKey: \ListPluginTypeActionsRequest.nextToken,
            outputKey: \ListPluginTypeActionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPluginTypeActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of plugins to return.
    ///   - pluginType: The type of the plugin.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPluginTypeActionsPaginator(
        maxResults: Int? = nil,
        pluginType: PluginType,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPluginTypeActionsRequest, ListPluginTypeActionsResponse> {
        let input = ListPluginTypeActionsRequest(
            maxResults: maxResults, 
            pluginType: pluginType
        )
        return self.listPluginTypeActionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPluginTypeMetadata(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPluginTypeMetadataPaginator(
        _ input: ListPluginTypeMetadataRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPluginTypeMetadataRequest, ListPluginTypeMetadataResponse> {
        return .init(
            input: input,
            command: self.listPluginTypeMetadata,
            inputKey: \ListPluginTypeMetadataRequest.nextToken,
            outputKey: \ListPluginTypeMetadataResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPluginTypeMetadata(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of plugin metadata items to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPluginTypeMetadataPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPluginTypeMetadataRequest, ListPluginTypeMetadataResponse> {
        let input = ListPluginTypeMetadataRequest(
            maxResults: maxResults
        )
        return self.listPluginTypeMetadataPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPlugins(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPluginsPaginator(
        _ input: ListPluginsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPluginsRequest, ListPluginsResponse> {
        return .init(
            input: input,
            command: self.listPlugins,
            inputKey: \ListPluginsRequest.nextToken,
            outputKey: \ListPluginsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPlugins(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the application the plugin is attached to.
    ///   - maxResults: The maximum number of documents to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPluginsPaginator(
        applicationId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPluginsRequest, ListPluginsResponse> {
        let input = ListPluginsRequest(
            applicationId: applicationId, 
            maxResults: maxResults
        )
        return self.listPluginsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRetrievers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRetrieversPaginator(
        _ input: ListRetrieversRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRetrieversRequest, ListRetrieversResponse> {
        return .init(
            input: input,
            command: self.listRetrievers,
            inputKey: \ListRetrieversRequest.nextToken,
            outputKey: \ListRetrieversResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRetrievers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application using the retriever.
    ///   - maxResults: The maximum number of retrievers returned.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRetrieversPaginator(
        applicationId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRetrieversRequest, ListRetrieversResponse> {
        let input = ListRetrieversRequest(
            applicationId: applicationId, 
            maxResults: maxResults
        )
        return self.listRetrieversPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSubscriptions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSubscriptionsPaginator(
        _ input: ListSubscriptionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSubscriptionsRequest, ListSubscriptionsResponse> {
        return .init(
            input: input,
            command: self.listSubscriptions,
            inputKey: \ListSubscriptionsRequest.nextToken,
            outputKey: \ListSubscriptionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSubscriptions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application linked to the subscription.
    ///   - maxResults: The maximum number of Amazon Q Business subscriptions to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSubscriptionsPaginator(
        applicationId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSubscriptionsRequest, ListSubscriptionsResponse> {
        let input = ListSubscriptionsRequest(
            applicationId: applicationId, 
            maxResults: maxResults
        )
        return self.listSubscriptionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWebExperiences(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWebExperiencesPaginator(
        _ input: ListWebExperiencesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWebExperiencesRequest, ListWebExperiencesResponse> {
        return .init(
            input: input,
            command: self.listWebExperiences,
            inputKey: \ListWebExperiencesRequest.nextToken,
            outputKey: \ListWebExperiencesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWebExperiences(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The identifier of the Amazon Q Business application linked to the listed web experiences.
    ///   - maxResults: The maximum number of Amazon Q Business Web Experiences to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWebExperiencesPaginator(
        applicationId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWebExperiencesRequest, ListWebExperiencesResponse> {
        let input = ListWebExperiencesRequest(
            applicationId: applicationId, 
            maxResults: maxResults
        )
        return self.listWebExperiencesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchRelevantContent(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchRelevantContentPaginator(
        _ input: SearchRelevantContentRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchRelevantContentRequest, SearchRelevantContentResponse> {
        return .init(
            input: input,
            command: self.searchRelevantContent,
            inputKey: \SearchRelevantContentRequest.nextToken,
            outputKey: \SearchRelevantContentResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchRelevantContent(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The unique identifier of the Amazon Q Business application to search.
    ///   - attributeFilter: 
    ///   - contentSource: The source of content to search in.
    ///   - maxResults: The maximum number of results to return.
    ///   - queryText: The text to search for.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchRelevantContentPaginator(
        applicationId: String,
        attributeFilter: AttributeFilter? = nil,
        contentSource: ContentSource,
        maxResults: Int? = nil,
        queryText: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchRelevantContentRequest, SearchRelevantContentResponse> {
        let input = SearchRelevantContentRequest(
            applicationId: applicationId, 
            attributeFilter: attributeFilter, 
            contentSource: contentSource, 
            maxResults: maxResults, 
            queryText: queryText
        )
        return self.searchRelevantContentPaginator(input, logger: logger)
    }
}

extension QBusiness.GetChatControlsConfigurationRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.GetChatControlsConfigurationRequest {
        return .init(
            applicationId: self.applicationId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.ListApplicationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListApplicationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.ListAttachmentsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListAttachmentsRequest {
        return .init(
            applicationId: self.applicationId,
            conversationId: self.conversationId,
            maxResults: self.maxResults,
            nextToken: token,
            userId: self.userId
        )
    }
}

extension QBusiness.ListChatResponseConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListChatResponseConfigurationsRequest {
        return .init(
            applicationId: self.applicationId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.ListConversationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListConversationsRequest {
        return .init(
            applicationId: self.applicationId,
            maxResults: self.maxResults,
            nextToken: token,
            userId: self.userId
        )
    }
}

extension QBusiness.ListDataAccessorsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListDataAccessorsRequest {
        return .init(
            applicationId: self.applicationId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.ListDataSourceSyncJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListDataSourceSyncJobsRequest {
        return .init(
            applicationId: self.applicationId,
            dataSourceId: self.dataSourceId,
            endTime: self.endTime,
            indexId: self.indexId,
            maxResults: self.maxResults,
            nextToken: token,
            startTime: self.startTime,
            statusFilter: self.statusFilter
        )
    }
}

extension QBusiness.ListDataSourcesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListDataSourcesRequest {
        return .init(
            applicationId: self.applicationId,
            indexId: self.indexId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.ListDocumentsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListDocumentsRequest {
        return .init(
            applicationId: self.applicationId,
            dataSourceIds: self.dataSourceIds,
            indexId: self.indexId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.ListGroupsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListGroupsRequest {
        return .init(
            applicationId: self.applicationId,
            dataSourceId: self.dataSourceId,
            indexId: self.indexId,
            maxResults: self.maxResults,
            nextToken: token,
            updatedEarlierThan: self.updatedEarlierThan
        )
    }
}

extension QBusiness.ListIndicesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListIndicesRequest {
        return .init(
            applicationId: self.applicationId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.ListMessagesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListMessagesRequest {
        return .init(
            applicationId: self.applicationId,
            conversationId: self.conversationId,
            maxResults: self.maxResults,
            nextToken: token,
            userId: self.userId
        )
    }
}

extension QBusiness.ListPluginActionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListPluginActionsRequest {
        return .init(
            applicationId: self.applicationId,
            maxResults: self.maxResults,
            nextToken: token,
            pluginId: self.pluginId
        )
    }
}

extension QBusiness.ListPluginTypeActionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListPluginTypeActionsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            pluginType: self.pluginType
        )
    }
}

extension QBusiness.ListPluginTypeMetadataRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListPluginTypeMetadataRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.ListPluginsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListPluginsRequest {
        return .init(
            applicationId: self.applicationId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.ListRetrieversRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListRetrieversRequest {
        return .init(
            applicationId: self.applicationId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.ListSubscriptionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListSubscriptionsRequest {
        return .init(
            applicationId: self.applicationId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.ListWebExperiencesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.ListWebExperiencesRequest {
        return .init(
            applicationId: self.applicationId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension QBusiness.SearchRelevantContentRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> QBusiness.SearchRelevantContentRequest {
        return .init(
            applicationId: self.applicationId,
            attributeFilter: self.attributeFilter,
            contentSource: self.contentSource,
            maxResults: self.maxResults,
            nextToken: token,
            queryText: self.queryText
        )
    }
}
